template and typedef

[Berardino la Torre]

Hi All,

is it possible to do something like this ? :

template <typename Base>
class Object : public Base::Interface {
};

class IA{
virtual void print()=0;
};

class A : public Object<A>{
public:
typedef IA A::Interface;
void print(){
}
};


int main(){

return 0;
}

thx

Bera

 

[Victor Bazarov]

is it possible to do something like this ? :

template <typename Base>
class Object : public Base::Interface {
};

class IA{
virtual void print()=0;
};

class A : public Object<A>{
public:
typedef IA A::Interface;
void print(){
}
};


int main(){

return 0;
}

What is the intent here? I have hard time figuring out what you
are trying to accomplish. Perhaps if you would show the _use_ for
class A or class IA...

V

 

[Kira Yamato]

Hi All,

is it possible to do something like this ? :

template <typename Base>
class Object : public Base::Interface {
};

g++ seems to complain that you cannot inherit from an incomplete type Base.

This is interesting. Just when you think you've figured out how
template works, here comes another example showing you how much you
don't know.

class IA{
virtual void print()=0;
};

class A : public Object<A>{
public:
typedef IA A::Interface;
void print(){
}
};

Seems like your goal is to have class A inherit from A::Interface. So,
why not consider the following:

class IA {};

class A : public IA
{
public:
typedef IA Interface;
};

 

[Kira Yamato]

g++ seems to complain that you cannot inherit from an incomplete type Base.

This is interesting. Just when you think you've figured out how
template works, here comes another example showing you how much you
don't know.

Well I suppose it makes sense that this should be an error. It's
basically a circular definition that could lead to infinite regress.
For example,

template<class T>
class A : public T {};

class B : public A<B>
{
int x;
};

But this code expands to

class B : public B
{
int x;
};

Hence the infinite regress.

 

[Jeff Schwab]

Hi All,

is it possible to do something like this ? :

[Summarized for brevity:]

template <typename Base>
struct Object: Base::Interface { };

struct IA { virtual void print() =0; };

struct A: Object<A> {
typedef IA A::Interface;
void print() { }
};


You're trying to derive a class (indirectly) from a type defined within
that class. I don't know of any direct way to do that. You can instead
move the type definition outside the class itself, e.g. into a traits class:

template<typename T>
struct Interface;

template <typename Base>
struct Object: Interface<Base>::Type { };

struct IA { virtual void print() =0; };

struct A;

template<>
struct Interface<A> {
typedef IA Type;
};

struct A: Object<A> {
void print() { }
};

 

[James Kanze]

[Berardino's original post isn't showing up here, but...]

[Summarized for brevity:]

template <typename Base>
struct Object: Base::Interface { };

This line isn't legal C++. What it almost certainly should be
is:

struct Object : typename Base::Interface {} ;

struct IA { virtual void print() =0; };

struct A: Object<A> {
typedef IA A::Interface;
void print() { }
};

You're trying to derive a class (indirectly) from a type
defined within that class.

Which is impossible, templates or not.

 

[gpderetta]

[Berardino's original post isn't showing up here, but...]

[Summarized for brevity:]
template <typename Base>
struct Object: Base::Interface { };

This line isn't legal C++.

This is actually legal and correct. In that context you can only have
a typename,
so you do not need to add the 'typename' keyword. There is no
ambiguity.

What it almost certainly should be
is:

struct Object : typename Base::Interface {} ;

And this is not. Both gcc and comeau online complain that typename is
not allowed in this context.

As if the rules weren't complicated enough... .
IIRC the next standard will relax the rule
and allow (but not require) a typename there.

HTH,