conversion operator in template

[Muthuveerappan]

Hi,

Brief description:
---------------------
I have a conversion operator that seems to work ok when used without templates.
But the conversion operator doesn't seem to be working when used with templates.

Example (complete code is given below):
------------------------------------------------
I have 2 template classes, ClassA<T> and ClassB<T>

ClassB has a conversion operator to convert ClassB to "const ClassA<T>* const"

Function f1 - without template
---------------------------------------

void f1(const ClassA<int>* const pPtrY).

When this function f1 is invoked by passing an object of ClassB<int>, the conversion operator gets invoked, and it is converted to "const ClassA<int>* const".

This works as expected

Function f2 - with template
----------------------------------

template<typename T>
void f2(const ClassA<T>* const pPtrY)

When this function f2 is invoked by passing an object of ClassB<T>, the conversion operator doesn't get invoked and hence throws an error.


Doubt
--------
Why does the conversion operator not work with templates ?
What is the underlying concept ?
Or am I missing something ?

complete code given below:

#include<iostream>

template<typename T>
class ClassA
{};

template<typename T>
class ClassB
{
    public:
        ClassB();
        ClassB(ClassA<T>* const pPtrX);       //Copy Constructor
        operator const ClassA<T>* const () const;   //Conversion Operator

    private:
        ClassA<T> *ptrX;

};

void f1(const ClassA<int>* const pPtrY)
{}

template<typename T>
void f2(const ClassA<T>* const pPtrY)
{}

int main()
{
    
    ClassA<int> *p1 = new ClassA<int>;
    ClassB<int> b1(p1);
    
    f1(b1);    //works ok, when without a template
               //conversion operator is invoked to convert b1 to ClassA<T>*
    
    //f2(b1);  //throws an error, when with a template
               //conversion operator is not invoked, can't understand why
               //what is the reason and what is the undelying concept ?
    return(0);
}

template<typename T>
ClassB<T> :: ClassB()
    : ptrX(NULL)
{}

template<typename T>
ClassB<T> :: ClassB(ClassA<T>* const pPtrX)
    : ptrX(pPtrX)
{}

template<typename T>
ClassB<T> :: operator const ClassA<T>* const () const
{
    return(ptrX);
}

[srishi1302]

Hello
Make this correction in your code
f2<int>(b1);

it will work

i copied ur code and corrected
its working ..

[JVene]

srishi1302 is correct, but if that's not quite what you want, here's a helper approach.

It appears that it's too much to ask the compiler to automatically determine T from ClassB<T>. It's not willing to reach inside ClassB to get the T out of it, and supply that to T for automatic generation of ClassA<T> types for the template function, but you can help it to know what you really mean.

try

template<typename T>
void f2i(const ClassA<T> * const pPtry)
{
}


template<typename T>
void f2(ClassB<T> & b )
{
 const ClassA<T> * const x = b;

 f2i( x );
}

The idea is to provide an interface for f2i which peals out the appropriate T for it to "know" you mean ClassA<T>, transporting the knowledge of T (interior to ClassB's type) to the call for f2i.

[Muthuveerappan]

Thanks a lot srishi1302 and Jvene

I think Jvene's solution is the best we have.


The following I guess is beyond my reach, but just thought I would state it:

I think (I might be completely wrong), the way variable declarations are parsed might be different from the way function calls are parsed, the reason I say that the following is accepted by the compiler:

(Variable declaration from Jvene's example - this works)

const ClassA<T> * const x = b;

(Function call which throws an error)

f2(b1);

[JVene]

This

const ClassA<T> * const x = b;

In the context of the template function already deduced T, so it was conveyed "outside" of ClassB<T>, where as in

f2(b1);

T is "inside" ClassB, and isn't conveyed as the T for ClassA<T>

...at least that's a colloquial way of describing it.