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

文章目录

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

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

cpp 复制代码

#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 函数（值传递）

cpp 复制代码

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 函数（引用传递）

cpp 复制代码

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 函数

cpp 复制代码

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: 10
  x after modification: 20
After modifyByValue:
  a: 10
Inside modifyByReference:
  x before modification: 10
  x 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` 示例

cpp 复制代码

#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` 示例

cpp 复制代码

#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。
Value of x: 10

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

文章目录

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

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

1. const int x 示例

2. const int &x 示例

1. `const int x` 示例

2. `const int &x` 示例