当前位置：首页 > news >正文

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

news 来源：原创 2024/9/22 13:46:02

文章目录

可以修改参数值的比较值传递(int x)和引用传递(int &x)
使用const不修改参数值的比较值传递(const int x)和引用传递(const int &x)
- 1. `const int x` 示例
- 2. `const int &x` 示例

可以修改参数值的比较值传递(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;
}

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。

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。

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;
}

#include <iostream>
- 包含输入输出流库，用于标准输入输出操作。
void printValue(const int x) {
- 定义了一个函数 printValue，它接受一个 const int 参数 x。x 是一个常量整型参数，函数内部不能修改它的值。
std::cout << "Value of x: " << x << std::endl;
- 打印 x 的值。由于 x 是传值的，函数内部对 x 的操作不会影响原始变量 a 的值。
// x = 20;
- 注释掉的代码，尝试修改 x 的值会引发编译错误，因为 x 是 const 的。
int main() {
- 主函数的开始。
int a = 10;
- 定义一个整型变量 a，并初始化为 10。
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;
}

逐行解释：

#include <iostream>
- 包含输入输出流库。
void displayValue(const int &x) {
- 定义了一个函数 displayValue，它接受一个 const int & 参数 x。这是一个常量整型引用，函数内部不能修改 x 引用的值。
std::cout << "Value of x: " << x << std::endl;
- 打印 x 的值。由于 x 是传引用的，函数内部对 x 的操作不会影响原始变量 a 的值。x 直接引用 a。
// x = 20;
- 注释掉的代码，尝试修改 x 的值会引发编译错误，因为 x 是 const 的。
int main() {
- 主函数的开始。
int a = 10;
- 定义一个整型变量 a，并初始化为 10。
displayValue(a);
- 调用 displayValue 函数，传递 a 的引用。此处，x 引用 a，所以 x 的值是 10。