＜c++基础(3)＞爱用值传递的不是好的c++程序员

压力一下，好人谁pass by value啊。

函数参数默认使用值传递，其一般过程:

1. 空间申请：

   当函数被调用时，会在栈上为局部变量分配内存空间。这包括函数的参数、局部变量以及函数调用时保存的上下文信息。

2. 拷贝构造：

   对于传递给函数的参数，如果是通过值传递，将会触发拷贝构造函数。这意味着会创建参数的一个副本，而不是直接传递参数本身。

3. 数据压栈：

   函数调用时，参数和局部变量的值都会被压入栈中。这确保了函数调用的局部数据在栈上有自己的空间，而不会与其他函数调用的数据相互干扰。

4. 函数执行：

   函数的实际代码开始执行，对参数和局部变量进行操作。

5. 弹栈：

   当函数执行完毕后，其局部变量和参数的值会从栈中弹出。这样，栈上的空间就可以被释放以供其他函数使用。

6. 析构：

   如果有对象是通过拷贝构造函数创建的，那么在函数执行完毕后，这些对象的析构函数将被调用。析构函数负责释放对象可能使用的任何资源。

7. 空间释放：

   随着函数的执行结束，为局部变量和参数分配的栈上空间会被释放，以便其他函数调用使用。

总体来说，值传递涉及到栈的使用，拷贝构造函数的调用，数据的传递和释放，以及对象的析构。这一系列步骤确保了函数调用的局部性和安全性，同时避免了对全局数据的污染。这同时意味着，当传递的参数是一个大型的类，其中包含各种函数内部用不到的各种成员同样会经历空间申请、拷贝构造、数据压栈、数据弹栈、析构和空间释放（每个数据成员都要经历构造析构，啊精彩）。这是对时间和计算机资源的巨大浪费，在函数被频繁调用时更甚。

值传递还有个隐患是派生类被声明为基类时，函数值传递调用基类构造函数实现拷贝构造，导致对象切割（slicing），传递到栈上的数据只有基类成员和方法。

而这个问题的解决办法，就是const引用。

为什么是引用

传给函数一个直接指向原始对象的地址，函数根据地址和声明的参数类型实现需要的数据提取。此时，

• 栈上不用分配和释放内存（当然地址存在函数栈上）
• 对于复杂的数据类型，可以避免复制，直接在原对象上操作
• 更容易地进行函数重载，无需为每个可能的类型都编写一个重载版本
• 可以接受字面常量作为参数
• 可以在函数内部统一对待传递的对象，使函数接口更加一致

引用可以提高代码的效率、可读性。

为什么是const

因为我们不希望原始变量被改变，尤其是程序很复杂的时候，如果不知道自己的变量在哪里被改变，那会是一场灾难。const能够让程序变得安全、健壮。

示例

说一万句不如show code，用一个例子说明const引用的必要性

#include <iostream>
#include <string>
#include <vector>

class SubClass {//细节不用看，理解为一个复杂类
public:
    SubClass(int value) : value_(value) {
        std::cout << "Creating SubClass with value: " << value_ << std::endl;
    }

    ~SubClass() {
        std::cout << "Destroying SubClass with value: " << value_ << std::endl;
    }

    // 假设这个类有一些复杂的成员函数和数据操作
    void performSubOperation() const {
        std::cout << "Performing sub operation with value: " << value_ << std::endl;
    }

private:
    int value_;
};

class DynamicArray {//细节不用看，理解为一个复杂类
public:
    DynamicArray(size_t size) : size_(size), data_(new int[size]) {
        std::cout << "Creating DynamicArray with size: " << size_ << std::endl;
    }

    ~DynamicArray() {
        delete[] data_;
        std::cout << "Destroying DynamicArray with size: " << size_ << std::endl;
    }

    // 假设这个类有一些复杂的成员函数和数据操作
    void fillData() {
        for (size_t i = 0; i < size_; ++i) {
            data_[i] = static_cast<int>(i);
        }
    }

    void printData() const {
        for (size_t i = 0; i < size_; ++i) {
            std::cout << data_[i] << " ";
        }
        std::cout << std::endl;
    }

private:
    size_t size_;
    int* data_;
};

class ComplexClass {//细节不用看，理解为一个包含多个复杂类作为成员的复杂类
public:
    ComplexClass(const std::string& data, int subValue, size_t arraySize)
        : data_(data), subObject_(subValue), dynamicArray_(arraySize) {
        std::cout << "Creating ComplexClass with data: " << data_ << std::endl;
    }

    ~ComplexClass() {
        std::cout << "Destroying ComplexClass with data: " << data_ << std::endl;
    }

    // 假设这个类有一些复杂的成员函数和数据操作
    void performComplexOperation() const {
        std::cout << "Performing complex operation with data: " << data_ << std::endl;
        subObject_.performSubOperation();
        dynamicArray_.printData();
    }

private:
    std::string data_;
    SubClass subObject_;
    DynamicArray dynamicArray_;
};

// 使用值传递的版本
void processComplexClassValue(ComplexClass obj) {
    std::cout << "Processing ComplexClass by value..." << std::endl;
    obj.performComplexOperation();
}

// 使用const引用的版本
void processComplexClassReference(const ComplexClass& obj) {
    std::cout << "Processing ComplexClass by reference..." << std::endl;
    obj.performComplexOperation();
}

int main() {
    // 创建一个复杂对象
    ComplexClass complexObject("Hello, Const Reference!", 42, 5);

    // 循环调用两个版本的函数，观察构造和析构函数的调用情况
    for (int i = 0; i < 3; ++i) {
        std::cout << "\nIteration " << i + 1 << ":\n";

        // 使用值传递的版本
        std::cout << "Calling processComplexClassValue...\n";
        processComplexClassValue(complexObject);

        // 使用const引用的版本
        std::cout << "Calling processComplexClassReference...\n";
        processComplexClassReference(complexObject);
    }

    return 0;
}

在这个示例中，ComplexClass 包含了一个字符串、一个 SubClass 对象和一个 DynamicArray 对象作为其成员。在 main 函数中添加了一个循环，循环调用了 processComplexClassValue 和 processComplexClassReference 函数。我们通过输出语句在每次调用之前输出了一些信息，以便观察构造和析构函数的调用情况。

通过观察输出，你将会看到在每次值传递的情况下，都会发生一次 ComplexClass 对象的构造和析构，而在使用 const 引用的情况下，仅发生一次析构。这表明在值传递的情况下，对象的复制导致了更多的构造和析构操作。这种差异在循环调用时可能会积累，特别是在处理更大型、更复杂的类对象时。

这个例子中，使用 const 引用可以更好地避免不必要的复制和构造销毁操作，因为它直接引用了原始对象。在实际应用中，这种避免不必要的复制对于性能的提升可能更为显著，尤其是在处理更复杂的类结构时。

备注

其实简单数据类型（内置类型、STL迭代器等）的时候值传递好一些。----《Effective C++ 第三版》条款20