Why is my constructor with non const reference as argument allowed to be called with temporary objects?

Question

I have a sample code below.

#include<iostream>

template<typename T>
class XYZ
{
   private:
   T & ref;
   public:
   XYZ(T & arg):ref(arg)
   {
   }
};
class temp
{
   int x;
   public:
   temp():x(34)
   {
   }
};
template<typename T>
void fun(T & arg)
{
}
int main()
{
   XYZ<temp> abc(temp());
   fun(temp());  //This is a compilation error in gcc while the above code is perfectly valid. 
}

In the above code even though XYZ constructor takes argument as non const reference, it compiles fine while the fun function fails to compile. Is this specific to g++ compiler or c++ standard has to say something about it?

Edit:

g++ -v gives this.

gcc version 4.5.2 (Ubuntu/Linaro 4.5.2-8ubuntu4)

Answer 1

 XYZ<temp> abc(temp());

It compiles, because it is NOT a variable declaration. I'm sure you think its a variable declaration when the fact is that its a function declaration. The name of the function is abc; the function returns an object of type XYZ<temp> and takes a single (unnamed) argument which in turn is a function returning type temp and taking no argument. See these topics for detail explanation:

• The Most Vexing Parse (at InformIT)
• Most vexing parse (at wikipedia)

And fun(temp()) doesn't compile, because temp() creates a temporary object and a temporary object cannot be bound to non-const reference.

So the fix is this : define your function template as:

template<typename T>
void fun(const T & arg) //note the `const`
{
}

Answer 2

No, the standard doesn't allow to pass a temporary to non const reference. (C++0X introduced rvalue reference to allow this in some controlled cases), see 8.5.3/5 (which is too long for me to cite, the meaningful part is otherwise, the reference shall be to a non-volatile const type, but you have to read the whole list of cases to know that they don't apply here).

And

XYZ<temp> abc(temp());

is simply yet another example of the most vexing parse.