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++.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[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
"Alf P. Steinbach" <al***@start.no> wrote in message
news:42****************@news.individual.net...

* ishekara:

void main()

That is not valid C++.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Shezan Baig]

ishekara wrote:

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-


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

[Martijn Mulder]

ishekara wrote:

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
"Alf P. Steinbach" <al***@start.no> wrote in message
news:42****************@news.individual.net...

* ishekara:

void main()

That is not valid C++.

--
A: Because it messes up the order in which people
normally read text. Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in
e-mail?

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);
}

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[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

"Shezan Baig" <sh************@gmail.com> wrote in message
news:11**********************@g14g2000cwa.googlegr oups.com...

ishekara wrote:

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-

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

[red floyd]

ishekara wrote:

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.