C++Talk.NET

Burnce · Guest

Hi,

I have a problem relating to template resolution.

I am writing some templates to be able to package objects into messages
for communication.

template <typename T>
int packSize(const T& data){
...
}

template<typename T>
void pack(const T& data, char* buffer, int bufferLength, int* position){
...
}

template<typename T>
T unpack(char* buffer, int bufferLength, int* position){
...
}

I would like to be able to send STL objects... therefore I have written:

template<>
int packSize(const string& data){
...
}

template<>
void pack(const string& data, char* buffer, int bufferLength, int* position){
...
}

template<>
string unpack<string>(char* buffer, int bufferLength, int* position,){
...
}

And for the vector class:

template<typename U>
int packSize(const vector& data){
...
}

template<typename U>
void pack(const vector& data,
char* buffer,
int bufferLength,
int* position){
...
}

Up to here things work fine. I can call:

string C = unpack<string>(data, buffer, length, &position);

But when I add this

template<typename U>
vector unpack(char* buffer, int bufferLength, int* position){
...
}

As long as I dont call unpack still things are fine. But if I call:

string C = unpack<string>(data, buffer, length, &position);

I get an error at compile time:

call of overloaded `unpack(char*&, int&, int*)' is ambiguous
candidates are:
T unpack(char*, int, int*) [with T = std::string]
std::vector<U, std::allocator<_CharT> > unpack(char*, int, int*)
[with U = std::string]

Is there a way to get around this? Is there a way to make
unpack<string>() call the first unpack template and unpack<vector()
or unpack<vector call the second?

Thanks in advance,

Burnce

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Ciprian Ciubotariu · Guest

First I got a question for standard gurus: why is the syntax
template<class> void f<string>(...) accepted for functions? Is it a
compiler problem, or does the standard allow it?

I think the main reason why your program fails to compile is that
functions cannot be explicitly specialized, only overloaded. Overload
resolution is only dependent on the function parameters. (see 13.1
[over.load], paragraph 2)

The difference between packSize, pack and unpack is that the first two
have overloads for T, std::string, vector. The unpack is badly
overloaded (since you can't overload only based on return value) and the
program is ill-formed (if i understand the C++ standard correctly).

Since you specify explicit arguments to your call to unpack (i.e.
unpack<string>) the compiler only considers template<class T> T
unpack(...) and template<class U> vector unpack(...) and not
std::string unpack(...). If you try calling string C = unpack(...) you
will get ambiguity for all "overloads" of unpack.

My personal solution to this problem is to use class template
specializations if you really need a return type.

template<class T> struct unpack {
static T unpack(...);
};
template<> struct unpack<string> {
static string unpack(...);
};
template<class U> struct unpack<vector {
static vector unpack(...);
};

A better idea might be to add an "out" parameter to unpack, thus
bringing the "return value" into the parameter list of unpack:

template<class T> void unpack(..., T& result);
template<class U> void unpack(..., vector& result);
void unpack(..., string & result);

Cheers,

Cipi

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

kanze@gabi-soft.fr · Guest

Burnce wrote:

msalters · Guest

Ciprian Ciubotariu wrote:

Ciprian Ciubotariu · Guest

msalters wrote: