c ++模板类，initialization（）vs {}

Question

I am wondering why I can't initialize an instance of the following template class with () instead of {} within the scope of another class (C++ 11)? error: expected identifier before numeric constant

template <typename T>
class vec3 {

private:

    T   data[3];

public:

    vec3 (T a, T b, T c);
};

template <typename T> 
vec3<T>::vec3 (T a, T b, T c) 
{
    data[0] = a;
    data[1] = b;
    data[2] = c;
}

class whatever {

    vec3 <float> a (1,2,3); // not ok
    vec3 <float> b {1,2,3}; // ok

};

int main () {

    vec3 <float> a (1,2,3); // ok

    return 0;
}

Answer 1

That's simply a restriction on how class members can be initialised. You can use {} or = but not () .

I don't think there's a particularly compelling justification for the restriction; it's just one of the language's many quirks.

Answer 2

Initializers using () were disallowed in the proposal of non-static data member initializers - N2756 , for the reasons mentioned by @TC in the comment section:

Unfortunately, this makes initializers of the “ ( expression-list ) ” form ambiguous at the time that the declaration is being parsed:

 struct S { int i(x); // data member with initializer // ... static int x; }; struct T { int i(x); // member function declaration // ... typedef int x; }; 

One possible solution is to rely on the existing rule that, if a declaration could be an object or a function, then it's a function:

 struct S { int i(j); // ill-formed...parsed as a member function, // type j looked up but not found // ... static int j; }; 

A similar solution would be to apply another existing rule, currently used only in templates, that if T could be a type or something else, then it's something else; and we can use “typename” if we really mean a type:

 struct S { int i(x); // unabmiguously a data member int j(typename y); // unabmiguously a member function }; 

Both of those solutions introduce subtleties that are likely to be misunderstood by many users (as evidenced by the many questions on comp.lang.c++ about why “ int i(); ” at block scope doesn't declare a default-initialized int ). The solution proposed in this paper is to allow only initializers of the “ = initializer-clause ” and “ { initializer-list } ” forms.