By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
448,652 Members | 1,682 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 448,652 IT Pros & Developers. It's quick & easy.

Object instantiation gets parsed as func.def.?

P: n/a
Hi! This is the smallest example I was able to create to demonstratet the
problem. It seems that a certain kind of object instantiation gets parsed as
a function definition (or whatever) by the compiler. I don't know if it
comes from some (maybe not-so-)dark corner of the C++ standard, or VC7.1 has
got a bug.

Thx,
Agoston

//-----------------------------------
template<typename T>
struct A {
A(T t):t(t) {}
T t;
};

template<typename T> void f()
{
cout << T() << endl;
A<T> a1((T()));
A<T> a2(T()); // function definition?
cout << a1.t << endl;
cout << a2.t << endl; // compile error! (*)
}

int _tmain(int argc, _TCHAR* argv[])
{
f<int>();
return 0;
}

// (*) error message:
// error C2228: left of '.t' must have class/struct/union type
// type is 'overloaded-function'
// see reference to function template instantiation
// 'void f<int>(void)' being compiled

//--------------------------------------------
Nov 17 '05 #1
Share this Question
Share on Google+
1 Reply


P: n/a
Agoston Bejo wrote:
Hi! This is the smallest example I was able to create to demonstratet the
problem. It seems that a certain kind of object instantiation gets parsed as
a function definition (or whatever) by the compiler. I don't know if it
comes from some (maybe not-so-)dark corner of the C++ standard, or VC7.1 has
got a bug.
The "dark corner" theory is correct.
Thx,
Agoston

//-----------------------------------
template<typename T>
struct A {
A(T t):t(t) {}
T t;
};

template<typename T> void f()
{
cout << T() << endl;
A<T> a1((T()));
A<T> a2(T()); // function definition?
cout << a1.t << endl;
cout << a2.t << endl; // compile error! (*)
}

int _tmain(int argc, _TCHAR* argv[])
{
f<int>();
return 0;
}

// (*) error message:
// error C2228: left of '.t' must have class/struct/union type
// type is 'overloaded-function'
// see reference to function template instantiation
// 'void f<int>(void)' being compiled

//--------------------------------------------


VC is correct. This is what Scott Meyers described as a "vexing parse" in
"Effective STL". To simplify:

int f(int());

This declares a function f that has one parameter of the type:

int (*)();

That is, the parameter is unnamed and has type "pointer to a function that
has no parameters and returns int".

You've already discovered one way to get the effect you're after, namely
parenthesizing the ctor argument.

--
Doug Harrison
Microsoft MVP - Visual C++
Nov 17 '05 #2

This discussion thread is closed

Replies have been disabled for this discussion.