Implicit template argument deduction for classes

Hi all,

I just discovered that class template arguements are never implicitly deduced from their constructor arguements. Am I correct in thinking that the following code won't work (as I don't have access to a compiler)?

Code:

---

template<typename T> class basic_broken { /* ... */ };

template<typename T>
class broken { // bridge class
  basic_broken<T>* broken_impl;
public:
  broken( T* t )
    : broken_impl(t)
  {}
};

void f()
{
  int s;
  broken(&s); // Error: can't deduce template type of class broken?
}

---

Yeah, that looks broken to me. :)

I feared so. :( Thanks Noir.

Why fear? It's not that big of an issue, and if you need that kind of thing, you can wrap the construction of an object in a factory function that's also a template and deduces its arguments:

Code:

---

template <class T>
broken<T> make_more_broken( T arg ) {
  return broken<T>( arg );
}

---

Well, there's the forwarding issue. You have to write a function for each constructor. It's not insurmountable, but it sure is a hassle.

If you use default arguments smartly and don't bog down the class with constructors, it's not even a hassle.

Quote:

---

Originally Posted by Noir

Why fear? It's not that big of an issue, and if you need that kind of thing, you can wrap the construction of an object in a factory function that's also a template and deduces its arguments:

Code:

---

template <class T>
broken<T> make_more_broken( T arg ) {
  return broken<T>( arg );
}

---

---

Er, how would I call this function? The only ways that work seem to be

Code:

---

broken<int> code = make_more_broken(42);
//or
broken<int> code(make_more_broken(42));

---

Quote:

---

Originally Posted by anon

Er, how would I call this function? The only ways that work seem to be

Code:

---

broken<int> code = make_more_broken(42);
//or
broken<int> code(make_more_broken(42));

---

---

mostly these kinds of functions are used with other templates.

e.g.

Code:

---

template <typename T>
void print_thing(T t);

print_thing(make_more_broken(42));

---

in the next version of C++ the auto keyword will do what you want.

Code:

---

auto someVar = make_more_broken(42);

---

Quote:

---

Originally Posted by anon

Er, how would I call this function? The only ways that work seem to be

Code:

---

broken<int> code = make_more_broken(42);
//or
broken<int> code(make_more_broken(42));

---

---

Isn't the point of the factory functions so you can do something like:

Code:

---

broken code = make_more_broken(42); // template arg of code automatically deduced

---

Will that not work?

But you can't do that either. The point is that you can pass the result of the make_* function directly to a function template, e.g.

Code:

---

std::copy(in.begin(), in.end(), make_back_inserter(foo));

---

Until the auto keyword in C++09, if you want a variable, you'll have to explicitly declare its full type.

Quote:

---

Until the auto keyword in C++09, if you want a variable, you'll have to explicitly declare its full type.

---

The auto keyword already exists; are they redefining it?

I believe they are just adding to its uses.

http://www.open-std.org/jtc1/sc22/wg...2004/n1607.pdf

Okay, thanks for the link.