Why not infer template parameter from constructor?

Question

Hi all, my question today is pretty simple: why can't the compiler infer template parameters from class constructors, much as it can do from function parameters? For example, why couldn't the following code be valid:

template<typename obj>
class Variable {
      obj data;
      public: Variable(obj d)
              {
                   data = d;
              }
};

int main()
{
    int num = 2;
    Variable var(num); //would be equivalent to Variable<int> var(num),
    return 0;          //but actually a compile error
}

As I say, I understand that this isn't valid, so my question is why isn't it? Would allowing this create any major syntactic holes? Is there an instance where one wouldn't want this functionality (where inferring a type would cause issues)? I'm just trying to understand the logic behind allowing template inference for functions, yet not for suitably-constructed classes.

Thanks

Answer 1

You are right the compiler could easily guess, but it's not in the standard or C++0x as far as I know so you'll have to wait atleast 10 more years (ISO standards fixed turn around rate) before compiller providers add this feature

Answer 2

Making the ctor a template the Variable can have only one form but various ctors:

class Variable {
      obj data; // let the compiler guess
      public:
      template<typename obj>
      Variable(obj d)
       {
           data = d;
       }
};

int main()
{
    int num = 2;
    Variable var(num);  // Variable::data int?

    float num2 = 2.0f;
    Variable var2(num2);  // Variable::data float?
    return 0;         
}

See? We can not have multiple Variable::data members.

Answer 3

See The C++ Template Argument Deduction for more info on this.

Answer 4

I think it is not valid because the constructor isn't always the only point of entry of the class (I am talking about copy constructor and operator=). So suppose you are using your class like this :

MyClass m(string s);
MyClass *pm;
*pm = m;

I am not sure if it would be so obvious for the parser to know what template type is the MyClass pm;

Not sure if what I said make sense but feel free to add some comment, that's an interesting question.

Answer 5

A lot of classes don't depend on constructor parameters. There are only a few classes that have only one constructor, and parameterize based on this constructor's type(s).

If you really need template inference, use a helper function:

template<typename obj>
class Variable 
{
      obj data;
public: 
      Variable(obj d)
      : data(d)
      { }
};

template<typename obj>
inline Variable<obj> makeVariable(const obj& d)
{
    return Variable<obj>(d);
}

Answer 6

Supposing that the compiler supports what you asked. Then this code is valid:

Variable v1( 10); // Variable<int>

// Some code here

Variable v2( 20.4); // Variable<double>

Now, I have the same type name (Variable) in the code for two different types (Variable and Variable). From my subjective point of view, it affects the readability of the code pretty much. Having same type name for two different types in the same namespace looks misleading to me.

Later update: Another thing to consider: partial (or full) template specialization.

What if I specialize Variable and provide no constructor like you expect?

So I would have:

template<>
class Variable<int>
{
// Provide default constructor only.
};

Then I have the code:

Variable v( 10);

What should the compiler do? Use generic Variable class definition to deduce that it is Variable, then discover that Variable doesn't provide one parameter constructor?

Answer 7

Let's look at the problem with reference to a class everyone should be familar with - std::vector.

Firstly, a very common use of vector is to use the constructor that takes no parameters:

vector <int> v;

In this case, obviously no inference can be performed.

A second common use is to create a pre-sized vector:

vector <string> v(100);

Here, if inference were used:

vector v(100);

we get a vector of ints, not strings, and presumably it isn't sized!

Lastly, consider constructors that take multiple parameters - with "inference":

vector v( 100, foobar() );      // foobar is some class

Which parameter should be used for inference? We would need some way of telling the compiler that it should be the second one.

With all these problems for a class as simple as vector, it's easy to see why inference is not used.

Answer 8

What you are trying to achieve is called type erasure. Take a look at boost::any and it's implementation how it works.

Boost Any

Now to the question, why it does not work. As boost::any demonstrates it is possible to implement. And it works, but your problem would be the dispatching which type is really inside. Contrary to template approach, you will be required to do dispatching at application runtime, since the contained type will be erased. There are 2 possibilities to handle that: Visitor pattern and custom cast implementation (which throws an exception if you are trying to cast to wrong type). In both cases you move compile time type safety to runtime and bypass the compiler's type checks.

Another approach is to introduce the Variant type: Boost Variant

Variant works differently as boost::any and allows only limited number of types to be stored. This introduces higher type safety, since you really limit the set of expected types. There is a nice article written by Andrey Alexandrescu in ddj, on how to implement such a variant: Part 1, Part 2, Part 3

It's implementation is a bit more complex as that of boost::any, but offer higher type safety and disallows users to put any possible types into the variant, with exception of those being explicitly declared.

As I said it can be implemented in C++, but requires deep knowledge of the language and good interface design, so that users of that class do not handle apples as peaches.

Please remember Henry Spencer's words: If you lie to the compiler, it will get its revenge.

Regards,

Ovanes

---

Idea of implementation (!untested!)

class any_type
{
    class any_container
    {
    public:
     virtual ~any_container(){}
     virtual void* pointer()=0;
     virtual type_info const& get_type()const=0;
    };

    template<class T>
    class any_container_impl
    {
     T t_;

    public:
     any_container_impl(T const& t)
      : t_(t)
     {}

     virtual ~any_container_impl(){}

     virtual void* pointer()
     {
      return &t_;
     }

     virtual type_info const& get_type()const
     {
      return typeid(T);
     }

    };

    std::auto_ptr<any_container> content_;

public:
    template<class T>
    any_type(T const& t)
     : content_(new any_container_impl<T>(t))
    {}

    template<class T>
    T* cast_to_ptr()
    {
     if(typeid(T)!=content_->get_type())
      return NULL;
     return reinterpret_cast<T*>(content_->pointer());
    }

    template<class T>
    T& cast_to_ref()
    {
     T* ptr = cast_to_ptr<T>();
     if(!ptr)
      throw std::logic_error("wrong type");
     return *ptr;
    }
};

---

Answer 9

Deduction of types is limited to template functions in current C++, but it's long been realised that type deduction in other contexts would be very useful. Hence C++0x's auto.

While exactly what you suggest won't be possible in C++0x, the following shows you can get pretty close:

template <class X>
Variable<typename std::remove_reference<X>::type> MakeVariable(X&& x)
{
    // remove reference required for the case that x is an lvalue
    return Variable<typename std::remove_reference<X>::type>(std::forward(x));
}

void test()
{
    auto v = MakeVariable(2); // v is of type Variable<int>
}

Answer 10

Still missing: It makes the following code quite ambiguous:

int main()
{
    int num = 2;
    Variable var(num);  // If equivalent to Variable<int> var(num),
    Variable var2(var); //Variable<int> or Variable<Variable<int>> ?
}