Can a C++ function returning a constant reference be protected from modification?

No, returning a constant reference from a function does not prevent modification. Because: a constant reference points to an unmodifiable value, but can point to a modifiable object. A const reference returned by a function may point to a non-const object, allowing it to be modified. Use const_cast to convert a const reference to a non-const reference and modify the variable it points to.

#Can a C function returning a constant reference prevent modification?

In C, a function can return a constant reference. This might seem like a way to prevent modifications to the referenced object, but it's not.

Definition of constant reference

A constant reference is a reference that points to a value that cannot be modified. This means that the value of the referenced object cannot be changed through a reference.

int main() {
  const int& x = 10; // x 引用常量 10
  x = 20; // 编译器错误：无法修改常量引用
  return 0;
}

Why does a function returning a constant reference not prevent modification?

Although a constant reference itself cannot be modified, it can still point to a modifiable object. The const reference returned by the function can point to a non-const object, as follows:

int f() {
  int x = 10;
  return x; // 返回 x 的常量引用
}

int main() {
  const int& y = f(); // y 是对 x 的常量引用
  y = 20; // 编译器错误：无法修改常量引用
  return 0;
}

In this case, even though y is a const reference, it points to x is not a constant, so x can still be modified.

Practical Case

The following is a practical C example that demonstrates that a constant reference returned by a function cannot prevent modification:

#include <iostream>

using namespace std;

int& GetNumber() {
  int x = 10;
  return x; // 返回 x 的常量引用
}

int main() {
  const int& num = GetNumber(); // num 是对 x 的常量引用
  
  // 通过修改 x 来间接修改 num
  int& x = const_cast<int&>(num);
  x = 20;
  
  cout << num << endl; // 输出 20

  return 0;
}

In the above example , the GetNumber() function returns a constant reference pointing to the local variable x. The main() function assigns this constant reference to num. Even though num is a const reference, it still points to x, and x is a modifiable object. By using the const_cast operator, the main() function can convert num to a non-const reference and modify the value of x, thus Indirectly modify num.

The above is the detailed content of Can a C++ function returning a constant reference be protected from modification?. For more information, please follow other related articles on the PHP Chinese website!