templates and inheritance

[er]

i have

class Impl; //abstract
class Impl_A:public Impl{...};//abstract
class Impl_B:public Impl{...};//abstract
class Impl_A_0: public Impl_A{/* implements */};

class S{ public: S(Impl*,...); ...};
class S_A: public S{ public: S_A(Impl_A* impl,...):S(impl){};
class S_B: public S{ public: S_B(Impl_B* impl,...):S(impl){};
//hierarchy ends here

template<typename T,typename U>
std::vector<Umult(T* pimpl){
//calls U(pimpl,...);
};

a) std::vector<S_Avec(mult<Impl_A0*,S_A>(Impl_A0*)); //ok
b) std::vector<S_Avec(mult(Impl_A0*)); //compiler error: no
matching function

i would have thought that T and U are implicitly specified by the
input and return type, respectively, so that b) would work?

Overloading like this does not work because i loose information about
the leaf class (Impl_A0* in example):
std::vector<S_Amult_A(Impl_A* pimpl){return mult(pimpl);}
std::vector<S_Bmult_A(Impl_B* pimpl){return mult(pimpl);}

any suggestion?

[Victor Bazarov]

er wrote:

i have

class Impl; //abstract
class Impl_A:public Impl{...};//abstract
class Impl_B:public Impl{...};//abstract
class Impl_A_0: public Impl_A{/* implements */};

class S{ public: S(Impl*,...); ...};
class S_A: public S{ public: S_A(Impl_A* impl,...):S(impl){};
class S_B: public S{ public: S_B(Impl_B* impl,...):S(impl){};
//hierarchy ends here

template<typename T,typename U>
std::vector<Umult(T* pimpl){
//calls U(pimpl,...);
};

a) std::vector<S_Avec(mult<Impl_A0*,S_A>(Impl_A0*)); //ok

OK -- what? 'vec' is a declaration of a function here, methinks.

b) std::vector<S_Avec(mult(Impl_A0*)); //compiler error: no
matching function

i would have thought that T and U are implicitly specified by the
input and return type, respectively, so that b) would work?

'vec' has overloaded constructors. How should the compiler know
that you intend to use the copy constructor? Yes, if it knew that
the intended specialisation of 'mult' returns a 'vec<S_A>', then
it might figure out that the copy c-tor is needed. But to know
what 'mult' to specialise (and how), it needs to know what your
'vec' constructor accepts as the argument. The classic catch-22.

Overloading like this does not work because i loose information about
the leaf class (Impl_A0* in example):
std::vector<S_Amult_A(Impl_A* pimpl){return mult(pimpl);}
std::vector<S_Bmult_A(Impl_B* pimpl){return mult(pimpl);}

any suggestion?

What exactly are you trying to accomplish?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[er]

On Sep 18, 6:39 pm, "Victor Bazarov" <[e-mail]:

er wrote:

i have

class Impl; //abstract
class Impl_A:public Impl{...};//abstract
class Impl_B:public Impl{...};//abstract
class Impl_A_0: public Impl_A{/* implements */};

class S{ public: S(Impl*,...); ...};
class S_A: public S{ public: S_A(Impl_A* impl,...):S(impl){};
class S_B: public S{ public: S_B(Impl_B* impl,...):S(impl){};
//hierarchy ends here

template<typename T,typename U>
std::vector<Umult(T* pimpl){
//calls U(pimpl,...);
};

a) std::vector<S_Avec(mult<Impl_A0*,S_A>(Impl_A0*)); //ok

OK -- what? 'vec' is a declaration of a function here, methinks.

b) std::vector<S_Avec(mult(Impl_A0*)); //compiler error: no
matching function

i would have thought that T and U are implicitly specified by the
input and return type, respectively, so that b) would work?

'vec' has overloaded constructors. How should the compiler know
that you intend to use the copy constructor? Yes, if it knew that
the intended specialisation of 'mult' returns a 'vec<S_A>', then
it might figure out that the copy c-tor is needed. But to know
what 'mult' to specialise (and how), it needs to know what your
'vec' constructor accepts as the argument. The classic catch-22.

Overloading like this does not work because i loose information about
the leaf class (Impl_A0* in example):
std::vector<S_Amult_A(Impl_A* pimpl){return mult(pimpl);}
std::vector<S_Bmult_A(Impl_B* pimpl){return mult(pimpl);}

any suggestion?

What exactly are you trying to accomplish?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

perhaps i should clarify that vec is the name i give to my vector that
i initialize with the output from mult.

[Victor Bazarov]

er wrote:

On Sep 18, 6:39 pm, "Victor Bazarov" <[e-mail]:

>er wrote:

>>i have

>>class Impl; //abstract
class Impl_A:public Impl{...};//abstract
class Impl_B:public Impl{...};//abstract
class Impl_A_0: public Impl_A{/* implements */};

>>class S{ public: S(Impl*,...); ...};
class S_A: public S{ public: S_A(Impl_A* impl,...):S(impl){};
class S_B: public S{ public: S_B(Impl_B* impl,...):S(impl){};
//hierarchy ends here

>>template<typename T,typename U>
std::vector<Umult(T* pimpl){
//calls U(pimpl,...);
};

>>a) std::vector<S_Avec(mult<Impl_A0*,S_A>(Impl_A0*)); //ok

OK -- what? 'vec' is a declaration of a function here, methinks.

>>b) std::vector<S_Avec(mult(Impl_A0*)); //compiler error: no
matching function

>>i would have thought that T and U are implicitly specified by the
input and return type, respectively, so that b) would work?

'vec' has overloaded constructors. How should the compiler know
that you intend to use the copy constructor? Yes, if it knew that
the intended specialisation of 'mult' returns a 'vec<S_A>', then
it might figure out that the copy c-tor is needed. But to know
what 'mult' to specialise (and how), it needs to know what your
'vec' constructor accepts as the argument. The classic catch-22.

>>Overloading like this does not work because i loose information
about the leaf class (Impl_A0* in example):
std::vector<S_Amult_A(Impl_A* pimpl){return mult(pimpl);}
std::vector<S_Bmult_A(Impl_B* pimpl){return mult(pimpl);}

>>any suggestion?

What exactly are you trying to accomplish?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

perhaps i should clarify that vec is the name i give to my vector that
i initialize with the output from mult.

The statement

vector<intvec(mult(char*));

is not a declaration of a vector. And if 'mult' is a function, it is
a syntax error because a type is passed to the function instead of
a value.

Please follow the recommendations of FAQ 5.8.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[er]

On Sep 18, 7:07 pm, "Victor Bazarov" <[e-mail]:

er wrote:

On Sep 18, 6:39 pm, "Victor Bazarov" <[e-mail]:

er wrote:
i have

>class Impl; //abstract
class Impl_A:public Impl{...};//abstract
class Impl_B:public Impl{...};//abstract
class Impl_A_0: public Impl_A{/* implements */};

>class S{ public: S(Impl*,...); ...};
class S_A: public S{ public: S_A(Impl_A* impl,...):S(impl){};
class S_B: public S{ public: S_B(Impl_B* impl,...):S(impl){};
//hierarchy ends here

>template<typename T,typename U>
std::vector<Umult(T* pimpl){
//calls U(pimpl,...);
};

>a) std::vector<S_Avec(mult<Impl_A0*,S_A>(Impl_A0*)); //ok

OK -- what? 'vec' is a declaration of a function here, methinks.

>b) std::vector<S_Avec(mult(Impl_A0*)); //compiler error: no
matching function

>i would have thought that T and U are implicitly specified by the
input and return type, respectively, so that b) would work?

'vec' has overloaded constructors. How should the compiler know
that you intend to use the copy constructor? Yes, if it knew that
the intended specialisation of 'mult' returns a 'vec<S_A>', then
it might figure out that the copy c-tor is needed. But to know
what 'mult' to specialise (and how), it needs to know what your
'vec' constructor accepts as the argument. The classic catch-22.

>Overloading like this does not work because i loose information
about the leaf class (Impl_A0* in example):
std::vector<S_Amult_A(Impl_A* pimpl){return mult(pimpl);}
std::vector<S_Bmult_A(Impl_B* pimpl){return mult(pimpl);}

>any suggestion?

What exactly are you trying to accomplish?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

perhaps i should clarify that vec is the name i give to my vector that
i initialize with the output from mult.

The statement

vector<intvec(mult(char*));

is not a declaration of a vector. And if 'mult' is a function, it is
a syntax error because a type is passed to the function instead of
a value.

Please follow the recommendations of FAQ 5.8.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

ok, i see what you mean. please consider:

ImplA0* pimpl=new Impl_A0;
a) std::vector<S_Avec=mult<Impl_A0,S_A>(pimpl); //ok
b) std::vector<S_Avec=mult(pimpl); //compiler error

[Victor Bazarov]

er wrote:

On Sep 18, 7:07 pm, "Victor Bazarov" <[e-mail]:

>er wrote:

>>On Sep 18, 6:39 pm, "Victor Bazarov" <[e-mail]>
wrote:
er wrote:
i have

>>>>class Impl; //abstract
class Impl_A:public Impl{...};//abstract
class Impl_B:public Impl{...};//abstract
class Impl_A_0: public Impl_A{/* implements */};

>>>>class S{ public: S(Impl*,...); ...};
class S_A: public S{ public: S_A(Impl_A* impl,...):S(impl){};
class S_B: public S{ public: S_B(Impl_B* impl,...):S(impl){};
//hierarchy ends here

>>>>template<typename T,typename U>
std::vector<Umult(T* pimpl){
//calls U(pimpl,...);
};

[..]

ok, i see what you mean. please consider:

ImplA0* pimpl=new Impl_A0;
a) std::vector<S_Avec=mult<Impl_A0,S_A>(pimpl); //ok
b) std::vector<S_Avec=mult(pimpl); //compiler error

Change your 'mult' definition to

template<class U, class T>
std::vector<Umult(T* pimpl) { ...

Then you could do

std::vector<S_Avec = mult<S_A>(pimpl);

The reason it won't work without <S_Aafter 'mult' is that
you cannot expect the compiler to deduce the 'U' type without
the argument and unclear return value type (see my mention
of 'catch-22' earlier). The deduction of the template return
value type can only successfully happen if a function pointer
is initialised from a template:

vector<int(*pf)(char*) = mult;

(should deduce 'U' as 'int' and 'T' as 'char').

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask