Why Can't I Use a Non-Const Reference to Bind a Temporary Object in C ?

Why not Non-const Reference to Temporary Objects?

In C , temporary objects created during an expression can only be assigned to const references, but not non-const references. This has raised questions about the rationale behind this restriction.

The conventional explanation is based on the potential hazards of modifying temporary objects. If a non-const reference to a temporary was allowed, it could be unintentionally modified, leading to unpredictable consequences. However, critics argue that reading from temporary objects is equally risky and should also be restricted.

To understand this distinction, consider the following example:

String& a = String("test");         // Error
const String& a = String("test");   // Ok

The first line is an error, while the second line is valid. This suggests that C is not concerned with reading from temporary objects. So, why is writing prohibited?

The answer lies in a fundamental aspect of C : function parameters. If non-const references to temporaries were allowed, it would create an ambiguity when passing temporary objects to functions that accept references. For instance:

void inc(double& x)
{
    x += 0.1;
}

int i = 0;
inc(i);

In this example, when i is passed to inc(), it is unclear whether a reference to i is intended or if a temporary copy of i should be created. This ambiguity can lead to subtle errors.

By prohibiting non-const references to temporaries, C ensures that function parameters always refer to lvalues (non-temporary objects). This eliminates the potential for confusion and promotes code clarity.

The above is the detailed content of Why Can't I Use a Non-Const Reference to Bind a Temporary Object in C ?. For more information, please follow other related articles on the PHP Chinese website!