Re: boost::call_traits<T>::param_type
On 15 Sep., 22:38, tohava <toh...@gmail.com> wrote:
I would like to do something like this:
header file:
class ValueProxy {
void operator =(boost::call_traits<T>::param_type x)
{
...
}
};
source file:
int main()
{
ValueProxy p; p = 5;
}
The problem that occurs here is that the compiler cannot deduce
implicitly the template parameter T
I don't see any kind of template in your code. I'm assuming you meant
class ValueProxy {
public:
template<typename T>
ValueProxy& operator=(
typename boost::call_traits<T>::param_type x)
{
...
}
...
};
for operator = and therefore compilation fails with an error.
Right. This is to be expected. Think about what the compiler needs to
do in order to deduce T here. Consider specializations. Consider this
case, for example:
template<typename T> struct foo { typedef T type; };
template<> struct foo<int> { typedef double type; };
template<typename T>
void bar(typename foo<T>::type);
int main() {
bar<int> (3.14159265); // OK, T=int, foo<T>::type=double
bar<double>(24.0); // OK, T=double, foo<T>::type=double
bar(99.0); // How would you deduce T ?!
}
It's not reasonable to expect the compiler to be able to deduce T
here. The standard uses the term "non-deducible context". It says the
compiler doesn't need to try to deduce T in such cases. Sometimes one
deliberately introduces this "indirection" to create a non-deducible
context (that's what this class template called "identity" can be used
for).
How would you recommend to handle it?
Don't use boost::call_traits when "T" needs to be deduced. Use "T
const&" instead. You can achieve what you want (with overloaded
templates and SFINAE) but I don't think it's worth the hassle. Also,
keep in mind that if you only define a templated operator= the
compiler will still (try to) generate its default operator=
implicitly. The same is true for copy constructors.
Cheers!
SG
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]