c++语言中函数行参为什么有时候会使用到&

在C++中，函数参数有两种传递方式：值传递和引用传递。值传递是指将实参的值复制一份传递给形参，形参修改这份副本不会影响实参的值。而引用传递是指将实参的地址传递给形参，形参通过该地址可以直接修改实参的值。

因此，在函数声明或定义时，如果需要对函数外的变量进行修改，可以使用引用传递。在形参前面加上&符号表示这是一个引用类型的形参。使用&符号可以避免值传递的开销，并且可以让函数修改调用者的变量。

例如：

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 1, y = 2;
    swap(x, y);
    cout << x << " " << y << endl; // 输出 2 1
    return 0;
}

在上述代码中，swap函数中的a和b都是引用类型的形参。在调用swap函数时，实参x和y的地址被传递给了a和b，函数内部通过这些地址修改了x和y的值，因此在main函数中输出的x和y的值已经被交换了。

相关问题

使用c++语言，根据给出的层次遍历次序，创造二叉树

好的，我可以为您解答这个问题。根据层次遍历次序构建二叉树的方法是使用队列。具体步骤如下：

1. 创建一个队列，将层次遍历次序的第一个元素入队。

2. 然后循环执行以下步骤，直到队列为空：

a. 从队列中取出一个元素作为当前节点。

b. 从层次遍历次序中依次取出该节点的左子节点和右子节点，如果该节点有左子节点或右子节点，则将其入队。

c. 将当前节点和其左右子节点连接起来。

3. 返回根节点，即层次遍历次序的第一个元素。

下面是使用 C++ 语言实现的代码：

#include <iostream>
#include <queue>
using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

TreeNode* createTree(vector<int>& nums) {
    if (nums.empty()) return nullptr;

    queue<TreeNode*> q;
    int i = 0;
    TreeNode* root = new TreeNode(nums[i++]);
    q.push(root);

    while (!q.empty()) {
        TreeNode* cur = q.front();
        q.pop();

        if (i < nums.size()) {
            if (nums[i] != -1) {
                cur->left = new TreeNode(nums[i]);
                q.push(cur->left);
            }
            i++;
        }

        if (i < nums.size()) {
            if (nums[i] != -1) {
                cur->right = new TreeNode(nums[i]);
                q.push(cur->right);
            }
            i++;
        }
    }

    return root;
}

void preOrderTraversal(TreeNode* root) {
    if (root == nullptr) return;

    cout << root->val << " ";
    preOrderTraversal(root->left);
    preOrderTraversal(root->right);
}

int main() {
    vector<int> nums = {1, 2, 3, 4, -1, 5, 6, -1, -1, 7, -1, -1, -1, -1, -1};
    TreeNode* root = createTree(nums);
    preOrderTraversal(root); // 输出：1 2 4 5 7 3 6
    cout << endl;

    return 0;
}

这里用 -1 表示空节点。上述代码中的 `createTree` 函数接收一个层次遍历次序的 vector，返回构建的二叉树的根节点。`preOrderTraversal` 函数是前序遍历二叉树的实现，用于验证构建的二叉树是否正确。

写一篇关于 对象 / 变量 生命周期 管理的文章，包含 1. C++ 语言类构造函数 & 析构函数，以及对应new & delete 的用法 2. C语言中的 malloc /calloc & free 3.智能指针 4. 单例类 5. 容器相关的内容

对象/变量的生命周期管理是程序设计中非常重要的一部分，正确的管理可以避免内存泄漏和程序崩溃等问题。在本文中，我们将介绍C++语言中类构造函数和析构函数，以及对应的new和delete的用法，C语言中的malloc/calloc和free，智能指针，单例类以及容器相关的内容。

1. C++语言类构造函数 & 析构函数，以及对应new & delete的用法

C++中的类构造函数和析构函数是用来初始化和清理对象的函数。当一个对象被创建时，构造函数被自动调用，用来初始化对象的状态。当对象被销毁时，析构函数被自动调用，用来清理对象的状态。例如：

class MyClass {
public:
    MyClass() {
        // 构造函数
    }
    
    ~MyClass() {
        // 析构函数
    }
};

int main() {
    MyClass* obj = new MyClass(); // 调用构造函数
    delete obj; // 调用析构函数
    return 0;
}

在这个例子中，我们使用了new和delete来动态分配和释放对象。new用来调用构造函数，delete用来调用析构函数。使用new和delete的好处是可以动态管理对象的生命周期，避免内存泄漏。

2. C语言中的malloc/calloc & free

在C语言中，我们使用malloc和free来动态分配和释放内存。malloc函数用来分配指定字节数的内存空间，返回一个指向所分配内存的指针。free函数用来释放先前分配的内存空间。例如：

int* ptr = (int*)malloc(sizeof(int)); // 分配4个字节的内存空间
*ptr = 10; // 将整数10存储到所分配的内存空间中
free(ptr); // 释放内存空间

需要注意的是，malloc分配的内存空间必须手动释放，否则会出现内存泄漏的问题。

3. 智能指针

智能指针是一种可以自动管理内存的指针，避免了手动释放内存的麻烦。C++11引入了std::unique_ptr和std::shared_ptr两种智能指针。

std::unique_ptr是一种独占性智能指针，它所指向的对象只能有一个指针拥有。当unique_ptr被销毁时，它所指向的对象也会被销毁。例如：

{
    std::unique_ptr<int> ptr(new int(10)); // 分配内存空间并初始化为10
    // ...
} // unique_ptr被销毁，所指向的对象也会被销毁

std::shared_ptr是一种共享性智能指针，可以有多个指针共享同一个对象。当所有shared_ptr被销毁时，所指向的对象也会被销毁。例如：

{
    std::shared_ptr<int> ptr1(new int(10)); // 分配内存空间并初始化为10
    std::shared_ptr<int> ptr2 = ptr1; // ptr2和ptr1共享同一个对象
    // ...
} // ptr1和ptr2被销毁，所指向的对象也会被销毁

4. 单例类

单例类是一种只能创建一个实例的类。在程序中，我们有时候需要确保只有一个对象被创建，例如全局配置类。单例类可以通过私有化构造函数和静态成员变量来实现。例如：

class Config {
private:
    Config() {
        // 构造函数私有化
    }
    
    static Config* instance; // 静态成员变量
    
public:
    static Config* getInstance() {
        if (instance == nullptr) {
            instance = new Config(); // 创建单例对象
        }
        return instance;
    }
};

Config* Config::instance = nullptr; // 初始化静态成员变量

int main() {
    Config* config = Config::getInstance(); // 获取单例对象
    // ...
    return 0;
}

在这个例子中，我们使用了一个静态成员变量instance来保存单例对象的指针。通过getInstance函数来获取单例对象，如果instance为nullptr，则创建一个新的单例对象。

5. 容器相关的内容

容器是用来存储和管理对象的一种数据结构。C++提供了多种容器，例如vector、list、set等。容器可以动态管理对象的生命周期，可以方便地添加、删除、查找和遍历对象。

例如，使用vector容器来存储整数对象：

#include <vector>

int main() {
    std::vector<int> vec; // 定义一个vector容器
    vec.push_back(1); // 添加一个整数对象
    vec.push_back(2); // 添加一个整数对象
    vec.push_back(3); // 添加一个整数对象
    for (int i = 0; i < vec.size(); i++) {
        std::cout << vec[i] << std::endl; // 遍历vector容器
    }
    return 0;
}

在这个例子中，我们使用了vector容器来存储整数对象。使用push_back函数来添加整数对象，使用size函数来获取容器大小，使用[]运算符来访问容器中的对象。遍历容器时，可以使用for循环和迭代器。

总结

对象/变量的生命周期管理是程序设计中非常重要的一部分，正确的管理可以避免内存泄漏和程序崩溃等问题。本文介绍了C++语言类构造函数和析构函数，以及对应的new和delete的用法，C语言中的malloc/calloc和free，智能指针，单例类以及容器相关的内容。在实际开发中，我们需要根据具体情况选择合适的管理方式，避免内存泄漏和程序崩溃等问题的发生。