cpp代码编写总结(持续更新中)

bug

1. 类和结构体定以后要加“;”, 会导致很多不相关的错误；

cpp如何多CPU并行执行程序

• 多CPU等于多线程/进程吗?

cpp的map需要定义偏序运算符,什么时候适合用来替代vector<pair>?

cpp用类表示树节点，其中的子结点成员用类表示好还是类的指针表示好?

回答：如果子结点成员用类表示，会发生树节点无穷嵌套，根本无法初始化(会榨干内存)

在 C++ 中表示树节点时，使用类的指针来表示子节点通常是更常见和更灵活的做法。以下是使用类和使用指针的比较，以及推荐的实现方式。

使用类表示子节点

如果你直接在树节点类中使用子节点的类作为成员，可能会导致以下问题：

1. 内存占用: 如果树的深度很大，直接包含子节点类会导致每个节点都占用大量内存。
2. 灵活性: 直接包含子节点会使得树的结构固定，无法动态调整（例如，添加或删除子节点）。

使用指针表示子节点

使用指针（或智能指针）来表示子节点的优点包括：

1. 动态内存管理: 使用指针可以动态分配和释放内存，适合树这种动态结构。
2. 灵活性: 可以轻松地添加、删除和重组子节点。
3. 避免内存浪费: 只在需要时分配内存，避免了不必要的内存占用。

示例实现

以下是一个使用指针表示子节点的树节点类的示例：

#include <iostream>
#include <vector>
#include <memory> // 用于智能指针

class TreeNode {
public:
    int value; // 节点值
    std::vector<std::shared_ptr<TreeNode>> children; // 子节点指针

    TreeNode(int val) : value(val) {}

    // 添加子节点
    void addChild(int val) {
        children.push_back(std::make_shared<TreeNode>(val));
    }

    // 打印树的内容
    void print() {
        std::cout << value << " ";
        for (const auto& child : children) {
            child->print(); // 递归打印子节点
        }
    }
};

int main() {
    // 创建根节点
    auto root = std::make_shared<TreeNode>(1);
    root->addChild(2);
    root->addChild(3);
    root->children[0]->addChild(4);
    root->children[0]->addChild(5);

    // 打印树
    root->print(); // 输出: 1 2 4 5 3

    return 0;
}

关键点

1. 使用智能指针: 在示例中，使用 std::shared_ptr 来管理子节点的内存，避免手动管理内存带来的复杂性和潜在的内存泄漏。
2. 动态添加子节点: 通过 addChild 方法，可以动态地添加子节点。
3. 递归打印: print 方法使用递归来打印树的内容。

总结

在 C++ 中，使用指针（尤其是智能指针）来表示树节点的子节点是更灵活和高效的做法。它允许动态管理内存和树结构，适合树这种动态变化的数据结构。

为什么使用引用&将大型对象（如大数组、复杂结构体或类对象）作为参数传递给函数时，使用引用可以避免复制整个对象的开销?在C++中，使用引用（&）作为函数参数可以避免复制大型对象的开销，主要是因为引用实际上是一个别名，它并不创建对象的副本，而是直接引用原始对象的内存地址。以下是详细的解释

省流：这是指针

1. 对象的复制开销

当你将一个大型对象（如大数组、复杂结构体或类对象）作为参数传递给函数时，如果使用值传递（即不使用引用），C++会创建该对象的一个副本。这意味着：

• 内存分配：系统需要为副本分配新的内存空间。
• 数据复制：系统需要将原始对象的数据逐个复制到新分配的内存中。这对于大型对象来说，可能会消耗大量的时间和资源。

2. 引用的工作原理

使用引用作为参数时，函数接收的是原始对象的引用，而不是其副本。这意味着：

• 无额外内存分配：没有为副本分配新的内存，引用只是指向原始对象的内存地址。
• 无数据复制：没有将数据从原始对象复制到副本，函数直接操作原始对象。

3. 性能优势

由于引用避免了内存分配和数据复制的开销，使用引用作为参数传递大型对象时，性能显著提高。这在处理大型数据结构时尤其重要，因为复制操作可能会导致显著的性能下降。

示例代码

以下是一个简单的示例，展示了使用引用和不使用引用的性能差异：

#include <iostream>
#include <vector>
#include <chrono>

void processByValue(std::vector<int> vec) {
    // 模拟处理
    for (auto& v : vec) {
        v++;
    }
}

void processByReference(std::vector<int>& vec) {
    // 模拟处理
    for (auto& v : vec) {
        v++;
    }
}

int main() {
    std::vector<int> largeVector(1000000, 1); // 创建一个包含100万个元素的向量

    // 测试值传递
    auto start = std::chrono::high_resolution_clock::now();
    processByValue(largeVector);
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "Time taken by value: " 
              << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() 
              << " ms" << std::endl;

    // 测试引用传递
    start = std::chrono::high_resolution_clock::now();
    processByReference(largeVector);
    end = std::chrono::high_resolution_clock::now();
    std::cout << "Time taken by reference: " 
              << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() 
              << " ms" << std::endl;

    return 0;
}

代码解释

1. processByValue：使用值传递，创建了一个 std::vector<int> 的副本。
2. processByReference：使用引用传递，直接操作原始向量。
3. 性能测试：使用 std::chrono 测量两种方法的执行时间。

总结

使用引用作为参数传递大型对象可以显著提高性能，因为它避免了内存分配和数据复制的开销。这使得引用在处理大型数据结构时成为一种非常有效的选择。

cpp给函数传递形参用&引用的作用是什么?

在C++中，使用引用（&）作为函数参数的主要作用有以下几个方面：

1. 避免复制开销

• 当你将大型对象（如大数组、复杂结构体或类对象）作为参数传递给函数时，使用引用可以避免复制整个对象的开销。复制大型对象可能会消耗大量的时间和内存，而使用引用只会传递对象的地址，从而提高性能。

2. 允许函数修改参数

• 使用引用作为参数，函数可以直接修改传入的变量。这在需要在函数内部更新外部变量的情况下非常有用。例如，如果你想在函数中更新一个对象的状态，使用引用可以直接对原始对象进行修改，而不需要返回值。

3. 更清晰的语义

• 使用引用可以使函数的意图更加明确。通过引用传递参数，调用者可以清楚地知道该函数可能会修改传入的参数。这有助于提高代码的可读性和可维护性。

4. 支持多态性

• 引用可以用于实现多态性，特别是在处理基类和派生类对象时。通过引用，可以在不确定对象类型的情况下调用相应的成员函数。

示例代码

以下是一个简单的示例，展示了如何使用引用作为函数参数：

#include <iostream>

void increment(int& value) {
    value++; // 直接修改传入的参数
}

int main() {
    int num = 5;
    std::cout << "Before increment: " << num << std::endl;

    increment(num); // 传递引用
    std::cout << "After increment: " << num << std::endl;

    return 0;
}

代码解释

1. 函数定义:

   • void increment(int& value)：这里的 int& value 表示 value 是一个引用参数，指向传入的整数。

2. 修改参数:

   • 在 increment 函数中，直接对 value 进行自增操作，这将直接影响到 main 函数中的 num 变量。

3. 输出结果:

   • 在调用 increment(num) 后，num 的值被修改，输出结果显示了这一变化。

总结

使用引用作为函数参数可以提高性能、允许函数修改参数、提供更清晰的语义，并支持多态性。这使得引用在C++编程中成为一种非常有用的工具。

cpp把全局变量定义为局部变量在int main()函数中声明与定义,并用形参传递给相关的函数有什么好处?将全局变量定义为局部变量，并在 int main() 函数中声明与定义，然后通过形参传递给相关函数，具有以下几个显著的好处：

1. 减少全局状态的依赖

• 局部变量的作用域仅限于其所在的函数，这样可以减少对全局状态的依赖。函数不再依赖于全局变量的值，从而使得函数更加独立和可重用。

2. 提高可读性和可维护性

• 通过形参传递变量，可以清楚地看到函数所需的输入。这使得函数的接口更加明确，调用者可以一目了然地知道需要提供哪些数据。代码的可读性和可维护性因此提高。

3. 避免命名冲突

• 使用局部变量可以避免与其他作用域中的变量发生命名冲突。全局变量可能在不同的文件或模块中被定义，使用局部变量可以减少这种风险。

4. 提高可测试性

• 函数的可测试性提高，因为你可以轻松地传递不同的参数进行测试，而不需要依赖全局状态。这样可以更容易地进行单元测试，确保函数在不同输入下的行为。

5. 更好的内存管理

• 局部变量的生命周期仅限于其所在的函数，函数结束后会自动释放内存。全局变量则在程序运行期间一直存在，可能导致内存使用不当。

6. 增强函数的灵活性

• 通过形参传递，可以在不同的上下文中使用相同的函数，只需传递不同的参数。这使得函数更加灵活，能够处理多种情况。

示例代码

以下是一个简单的示例，展示了如何将全局变量替换为局部变量并通过形参传递：

#include <iostream>

// 函数使用形参
void printValue(int value) {
    std::cout << "Value: " << value << std::endl;
}

int main() {
    // 局部变量
    int localVar = 20;

    // 通过形参调用
    printValue(localVar); // 传递局部变量

    // 你可以在这里定义其他局部变量并传递
    int anotherVar = 30;
    printValue(anotherVar); // 传递另一个局部变量

    return 0;
}

总结

将全局变量定义为局部变量并通过形参传递给相关函数是一种良好的编程实践。这种方法提高了代码的可读性、可维护性和可测试性，减少了潜在的错误和复杂性，使得代码更加模块化和灵活。

随机数生成

1) 给srand()提供一个种子，它是一个unsigned int类型；
2) 调用rand()，它会根据提供给srand()的种子值返回一个随机数(在0到RAND_MAX之间)；
3) 根据需要多次调用rand()，从而不间断地得到新的随机数；
4) 无论什么时候，都可以给srand()提供一个新的种子，从而进一步"随机化"rand()的输出结果。 

#include <iostream>
#include <stdlib.h>
#include <time.h> 

using namespace std; 

int main()
{ 
        srand((unsigned)time(NULL)); 
        for(int i = 0; i < 10;i++ ) 
                cout << rand() << '/t';
        cout << endl; 
        return 0;
}

• 一定范围的随机数如下：

	int rand_range=100;
	cout << rand()%rand_range << '/t';