ambiguous call to overloaded

[ishekara]

Hi,

I am having a class template which is used to convert from one type another.
I am having a problem when i use the copy constructor with same type.

code.
#include "stdio.h"
template <class T>
class SPtr
{
public:
// Default constructor
SPtr() : mSptr(NULL){}
// constructor to convert. takes a different type i.e. T2
template<class T2>
SPtr(T2& p){}
// copy constructor.
template<>
SPtr(const SPtr<T>& p) {}
private:
T* mSptr;
};

void main()
{
const SPtr<int> p1;
SPtr<int> p2(p1);
}

here the SPtr<int> p2(p1) gives me an "ambiguous call to overloaded
function" error.
but if i put a const in the template for SPtr(const T2&p), it reolves the
ambiguity,
template<class T2>
SPtr(const T2& p){} // this will correct the problem.

Could someone explain this behaviour?

TFH
shekar

 

[Alf P. Steinbach]

* ishekara:

void main()

That is not valid C++.

 

[ishekara]

here is the revised post. is this C++??

Hi,

I am having a class template which is used to convert from one type another.
I am having a problem when i use the copy constructor with same type.

code.
#include "stdio.h"
template <class T>
class SPtr
{
public:
// Default constructor
SPtr() : mSptr(NULL){}
// constructor to convert. takes a different type i.e. T2
template<class T2>
SPtr(T2& p){}
// copy constructor.
template<>
SPtr(const SPtr<T>& p) {}
private:
T* mSptr;
};

int main()
{
const SPtr<int> p1;
SPtr<int> p2(p1);
return 0;
}

here the SPtr<int> p2(p1) gives me an "ambiguous call to overloaded
function" error.
but if i put a const in the template for SPtr(const T2&p), it reolves the
ambiguity,
template<class T2>
SPtr(const T2& p){} // this will correct the problem.

Could someone explain this behaviour?

TFH
shekar

 

[Shezan Baig]

Hi,

I am having a class template which is used to convert from one type another.
I am having a problem when i use the copy constructor with same type.

code.
#include "stdio.h"
template <class T>
class SPtr
{
public:
// Default constructor
SPtr() : mSptr(NULL){}
// constructor to convert. takes a different type i.e. T2
template<class T2>
SPtr(T2& p){}
// copy constructor.
template<>
SPtr(const SPtr<T>& p) {}

This should just be:

// copy constructor
SPtr(const SPtr& p) {}

(i.e., without "template <>" or "<T>").

Hope this helps,
-shez-

 

[Martijn Mulder]

here is the revised post. is this C++??

Hi,

I am having a class template which is used to convert
from one type another. I am having a problem when i use
the copy constructor with same type.

code.
#include "stdio.h"
template <class T>
class SPtr
{
public:
// Default constructor
SPtr() : mSptr(NULL){}
// constructor to convert. takes a different type i.e. T2
template<class T2>
SPtr(T2& p){}
// copy constructor.

Remove this line from your code:

template<>




SPtr(const SPtr<T>& p) {}
private:
T* mSptr;
};

int main()
{
const SPtr<int> p1;
SPtr<int> p2(p1);
return 0;
}

here the SPtr<int> p2(p1) gives me an "ambiguous call to
overloaded function" error.
but if i put a const in the template for SPtr(const
T2&p), it reolves the ambiguity,
template<class T2>
SPtr(const T2& p){} // this will correct the problem.

Could someone explain this behaviour?

TFH
shekar

You must remove template<> before the copy constructor, see above. Yes, this is
C++

 

[Alf P. Steinbach]

* ishekara:

[top-posting]

Do not top-post. See the FAQ. Corrected.

here is the revised post. is this C++??

With regard to the declaration of 'main', yes.

The following code compiles fine with GNU and Visual C++, spot
the significant difference:


#include <cstddef>

template <class T>
class SPtr
{
public:
// Default constructor
SPtr() : mSptr(NULL){}
// constructor to convert. takes a different type i.e. T2
template<class T2>
SPtr(T2& /*p*/){}
// copy constructor.
SPtr(const SPtr<T>& /*p*/) {}
private:
T* mSptr;
};

int main()
{
const SPtr<int> p1;
SPtr<int> p2(p1);
}

 

[ishekara]

Hi all,

thanks for your reply
I removed the template<>, still it is giving ambiguous error for me. i am
using VC++ for compiling.

The ambiguity goes away by adding const in front of T2, as in
template<class T2>
SPtr(const T2& /*p*/){}

any idea why this const is required?

TFH
shekar

 

[red floyd]

Hi all,

thanks for your reply
I removed the template<>, still it is giving ambiguous error for me. i am
using VC++ for compiling.

1. VC6 and VC.NET are known to have template issues. VC.NET 2K3 is
fairly good with regard to them.

2. Copy constructors should always use const references anyways, unless
there is an EXTREMELY good reason not to.