c++中加不加const的值传递和引用传递的区别

可以修改参数值的比较值传递(int x)和引用传递(int &x)

#include <iostream>void modifyByValue(int x) {std::cout << "Inside modifyByValue:" << std::endl;std::cout << "  x before modification: " << x << std::endl;x = 20;  // 修改副本std::cout << "  x after modification: " << x << std::endl;
}void modifyByReference(int &x) {std::cout << "Inside modifyByReference:" << std::endl;std::cout << "  x before modification: " << x << std::endl;x = 20;  // 修改原始变量std::cout << "  x after modification: " << x << std::endl;
}int main() {int a = 10;std::cout << "Before function calls:" << std::endl;std::cout << "  a: " << a << std::endl;modifyByValue(a);std::cout << "After modifyByValue:" << std::endl;std::cout << "  a: " << a << std::endl;modifyByReference(a);std::cout << "After modifyByReference:" << std::endl;std::cout << "  a: " << a << std::endl;return 0;
}

1. modifyByValue 函数（值传递）

void modifyByValue(int x) {std::cout << "Inside modifyByValue:" << std::endl;std::cout << "  x before modification: " << x << std::endl;x = 20;  // 修改副本std::cout << "  x after modification: " << x << std::endl;
}

• void modifyByValue(int x)：定义一个函数 modifyByValue，接受一个 int 类型的参数 x。这是值传递，x 是 a 的副本。
• std::cout << "Inside modifyByValue:" << std::endl;：打印当前在 modifyByValue 函数内部。
• std::cout << " x before modification: " << x << std::endl;：打印 x 的值（副本），值是 10。
• x = 20;：修改 x 的值。由于 x 是副本，这种修改不会影响 main 函数中的原始变量 a。
• std::cout << " x after modification: " << x << std::endl;：打印修改后的 x 的值，结果是 20。

2. modifyByReference 函数（引用传递）

void modifyByReference(int &x) {std::cout << "Inside modifyByReference:" << std::endl;std::cout << "  x before modification: " << x << std::endl;x = 20;  // 修改原始变量std::cout << "  x after modification: " << x << std::endl;
}

• void modifyByReference(int &x)：定义一个函数 modifyByReference，接受一个 int & 类型的参数 x。这是引用传递，x 是对原始变量的引用。
• std::cout << "Inside modifyByReference:" << std::endl;：打印当前在 modifyByReference 函数内部。
• std::cout << " x before modification: " << x << std::endl;：打印 x 的值（引用），值是 10。
• x = 20;：修改 x 的值，由于 x 是对 a 的引用，这会直接修改 a 的值。
• std::cout << " x after modification: " << x << std::endl;：打印修改后的 x 的值，结果是 20。

3. main 函数

int main() {int a = 10;std::cout << "Before function calls:" << std::endl;std::cout << "  a: " << a << std::endl;modifyByValue(a);std::cout << "After modifyByValue:" << std::endl;std::cout << "  a: " << a << std::endl;modifyByReference(a);std::cout << "After modifyByReference:" << std::endl;std::cout << "  a: " << a << std::endl;return 0;
}

• int a = 10;：定义一个整型变量 a，并初始化为 10。
• std::cout << "Before function calls:" << std::endl;：打印在调用函数之前 a 的值。
• std::cout << " a: " << a << std::endl;：打印 a 的值，结果是 10。
• modifyByValue(a);：调用 modifyByValue 函数，将 a 的值传递给函数。函数内部的 x 是 a 的副本，对 x 的修改不会影响 a。
• std::cout << "After modifyByValue:" << std::endl;：打印在调用 modifyByValue 函数之后 a 的值。
• std::cout << " a: " << a << std::endl;：打印 a 的值，结果仍然是 10，因为 modifyByValue 函数中的修改不影响原始变量。
• modifyByReference(a);：调用 modifyByReference 函数，将 a 的引用传递给函数。函数内部的 x 是 a 的引用，对 x 的修改直接影响 a。
• std::cout << "After modifyByReference:" << std::endl;：打印在调用 modifyByReference 函数之后 a 的值。
• std::cout << " a: " << a << std::endl;：打印 a 的值，结果是 20，因为 modifyByReference 函数中的修改影响了原始变量 a。

执行结果

Before function calls:a: 10
Inside modifyByValue:x before modification: 10x after modification: 20
After modifyByValue:a: 10
Inside modifyByReference:x before modification: 10x after modification: 20
After modifyByReference:a: 20

总结

- 值传递（int x）：函数接收 a 的副本，对副本的修改不会影响原始变量 a。在 modifyByValue 中，a 的值保持不变。
- 引用传递（int &x）：函数接收 a 的引用，对引用的修改会直接影响原始变量 a。在 modifyByReference 中，a 的值被修改为 20。

使用const不修改参数值的比较值传递(const int x)和引用传递(const int &x)

const int x 与 const int &x 的区别

在 C++ 中，const 关键字用于定义常量，意味着被修饰的变量的值不能被修改。const 可以与传值和传引用都不能改变元素值 的方式结合使用，效果有所不同。

• const int x：x 是一个常量整型参数，函数内部不能修改 x 的值。x 是以值的方式传递的，这意味着函数内部使用的是 x 的副本，而不是原始变量的引用。这种方式适用于传递小的基本数据类型。

• const int &x：x 是一个常量整型的引用，函数内部不能修改 x 引用的值。引用传递不会复制数据，只是传递了数据的引用。通常在传递较大的对象时使用，以提高效率并避免不必要的数据复制。

1. const int x 示例

#include <iostream>void printValue(const int x) {// 打印 x 的值std::cout << "Value of x: " << x << std::endl;// 尝试修改 x 的值（这会引发编译错误）// x = 20; // 错误: 'x' 是常量，不能被修改
}int main() {int a = 10;// 调用 printValue 函数，传递整数值printValue(a);return 0;
}

1. #include <iostream>

   • 包含输入输出流库，用于标准输入输出操作。

2. void printValue(const int x) {

   • 定义了一个函数 printValue，它接受一个 const int 参数 x。x 是一个常量整型参数，函数内部不能修改它的值。

3. std::cout << "Value of x: " << x << std::endl;

   • 打印 x 的值。由于 x 是传值的，函数内部对 x 的操作不会影响原始变量 a 的值。

4. // x = 20;

   • 注释掉的代码，尝试修改 x 的值会引发编译错误，因为 x 是 const 的。

5. int main() {

   • 主函数的开始。

6. int a = 10;

   • 定义一个整型变量 a，并初始化为 10。

7. printValue(a);

   • 调用 printValue 函数，传递 a 的值。此处，a 的值 10 被复制到 x 中。

执行结果：

Value of x: 10

2. const int &x 示例

#include <iostream>void displayValue(const int &x) {// 打印 x 的值std::cout << "Value of x: " << x << std::endl;// 尝试修改 x 的值（这会引发编译错误）// x = 20; // 错误: 'x' 是常量，不能被修改
}int main() {int a = 10;// 调用 displayValue 函数，传递整数变量的引用displayValue(a);return 0;
}

逐行解释：

1. #include <iostream>

   • 包含输入输出流库。

2. void displayValue(const int &x) {

   • 定义了一个函数 displayValue，它接受一个 const int & 参数 x。这是一个常量整型引用，函数内部不能修改 x 引用的值。

3. std::cout << "Value of x: " << x << std::endl;

   • 打印 x 的值。由于 x 是传引用的，函数内部对 x 的操作不会影响原始变量 a 的值。x 直接引用 a。

4. // x = 20;

   • 注释掉的代码，尝试修改 x 的值会引发编译错误，因为 x 是 const 的。

5. int main() {

   • 主函数的开始。

6. int a = 10;

   • 定义一个整型变量 a，并初始化为 10。

7. displayValue(a);

   • 调用 displayValue 函数，传递 a 的引用。此处，x 引用 a，所以 x 的值是 10。

Value of x: 10