const references initialized to a literal

[Mario F.]

Hi all,

I'm having an hard time understanding both the usefulness and the reason why I am allowed to write something as:

const int &ref = 12;

I understand I couldn't do this if I hadn't declared the reference as const. I also understand that the compiler transforms that code into something like:

const int temp = 12; //create a temporary object
const int &ref = temp; //bing the reference to the temporary object;

However, I cannot conceive a single use for this const reference initialized to a literal. Is there any?

Another problem is why am I allowed to intialize to a literal? I can understand why I am not on the case of non const references, but why am I on const references? Even on the highest warning level for C++ 2005 Express and using -Wall and -Wextra on Dev-Cpp I get no single warning.

[laserlight]

I think it would be for cases like:

void foo(const T& t = 0) {
	// ...
}

// ...
foo(1);

where (const) int (or whatever literal type in question) is convertible to some type T.

Another problem is why am I allowed to intialize to a literal? I can understand why I am not on the case of non const references, but why am I on const references?

I do not see why not. The const reference means that one will not be assigning to an rvalue.

[Mario F.]

Maybe i'm fixing myself too much on the reference definition, which states references cannot be assigned to diferent types. As such I cannot assign a double reference to an int type. It's bugging me that I can do exactly that by assigning an int const reference to a literal type.

So, probably, what this means is that constant references can be assigned to related types?

The following code worked, when I tested it:

int ival = 10;
const int &ref = ival;
const double &ref2 = ival;

cout << ival << " " << ref << " " << ref2 << endl

Your initial example, laserlight... you mean it is useful for function templates? I'm still green here

[laserlight]

Maybe i'm fixing myself too much on the reference definition, which states references cannot be assigned to diferent types.

hmm... I do not recall such a rule. My reasoning is that a reference is effectively an alias for what it refers to, so if what the reference refers to is convertible to another type, the reference too should be convertible to that type.

I think what you mean to say is that one cannot assign to a reference of a different type (but note the exception where polymorphism comes into play).

The contrast would then be between:

int main() {
	double a = 0.0;
	int& b = static_cast<int>(a);
}

which produces a compile error, and

int main() {
	double a = 0.0;
	const int& b = static_cast<int>(a);
}

which doesnt. In the latter my opinion is that it is safe for the rvalue to be passed to const reference, since the const-ness means the rvalue wont be changed.

As such I cannot assign a double reference to an int type.

You can assign a double (reference or not) to an int, but with possible loss of data.

Your initial example, laserlight... you mean it is useful for function templates?

Um, my example is a non-template function. My use of 'T' is just laziness since it can be any appropriate type.