【系统学C++】从C语言到C++（三）

变量的初始化

在C语言中，变量的初始化通常是在声明变量之后，通过一个赋值语句来完成的。然而，C++引入了更强大的初始化特性，这些特性使得变量在声明时就能被赋予初始值，从而提高了代码的可读性和安全性。

以下是从C语言到C++变量初始化的对比和说明：

C语言中的变量初始化

在C语言中，变量通常在声明后通过赋值语句进行初始化：

int x; // 声明一个整型变量x
x = 10; // 初始化x为10

C++中的变量初始化

C++提供了多种初始化变量的方式，其中一些是C语言所没有的。

1. 默认初始化：

   • 当定义变量时没有指定初值时，会进行默认初始化。
   • 对于内置类型（如int、double等），如果变量定义在函数内部（即{}内），则拥有未定义的值；如果定义在全局或命名空间作用域中（即{}外），则会被初始化为0。
   • 对于类类型的变量，默认初始化会调用其默认构造函数（如果存在的话）。

2. 拷贝初始化：

   • 拷贝初始化是指采用等号（=）进行初始化的方式。
   • 编译器会把等号右侧的初始值拷贝到新创建的对象中去。
   • 例如：int a = 0; 或 string str1 = "hello";

3. 直接初始化：

   • 直接初始化是指采用小括号的方式进行变量初始化（小括号里一定要有初始值）。
   • 直接初始化直接调用与实参匹配的构造函数。
   • 例如：int a(0); 或 string str1("hello");

4. 值初始化：

   • 值初始化是指使用了初始化器（即使用了圆括号或花括号）但却没有提供初始值的情况。
   • 对于内置类型，值初始化通常意味着初始化为0。
   • 对于类类型，值初始化会调用其默认构造函数（如果存在的话）。
   • 例如：int a = int(); 或 vector<int> vec(10);（这里的vec被值初始化为包含10个0的vector）

5. 列表初始化（C++11及以后）：

   • 对于数组、聚合类型（如结构体和类）等，可以使用花括号进行列表初始化。
   • 例如：int arr[3] = {1, 2, 3}; 或 struct Point { int x, y; }; Point p = {1, 2};

6. 构造函数初始化列表（针对类）：

   • 在创建类的对象时，可以通过构造函数初始化列表来初始化成员变量。
   • 这种方式在构造函数的函数体执行任何代码之前就已经对成员变量进行了初始化。
   • 例如：class MyClass { int value; public: MyClass(int v) : value(v) {} }; MyClass obj(10);

7. 统一初始化语法（C++11及以后）：

   • 使用花括号{}进行初始化，这种方式可以应用于所有类型的变量。
   • 例如：int x{10}; 或 double y{3.14};

总结：C++提供了多种初始化方式，包括默认初始化、拷贝初始化、直接初始化、值初始化、列表初始化、构造函数初始化列表和统一初始化语法。这些方式在不同的场景下有不同的用途，选择适当的初始化方式可以提高代码的可读性和安全性。

注意事项

• 在C++中，尽量使用初始化而不是赋值来设置变量的初始值，因为这可以避免一些潜在的问题，如未初始化变量的使用。
• 使用列表初始化和统一初始化语法可以提高代码的可读性和安全性，特别是在处理复杂的数据类型时。
• 对于类类型，尽量使用构造函数初始化列表来初始化成员变量，而不是在构造函数的函数体内进行赋值。这可以提高效率，并确保成员变量在构造函数体执行任何代码之前就已经被正确初始化。

if / switch 语句初始化

在C语言中，if 和 switch 语句本身并不直接支持初始化变量的功能。然而，你可以在if或switch语句之前初始化变量，并在条件判断或case标签中使用这些变量。

例如，在C语言中：

#include <stdio.h>  
  
int main() {  
    int x = 5; // 初始化变量  
  
    if (x == 5) {  
        printf("x is 5\n");  
    }  
  
    switch (x) {  
        case 5:  
            printf("x is 5 in switch\n");  
            break;  
        default:  
            printf("x is not 5 in switch\n");  
            break;  
    }  
  
    return 0;  
}

然而，在C++中，你可以使用作用域内的初始化（也称为内联初始化），这通常与if或switch语句没有直接关系，但可以在这些语句的上下文中使用。例如：

#include <iostream>  
  
int main() {  
    if (int x = 5; x == 5) { // 注意：C++17开始支持这种初始化  
        std::cout << "x is 5\n";  
    }  
  
    
      
    switch (int y = 5; y) {  
        case 5:  
            std::cout << "y is 5 in switch\n";  
            break;  
        default:  
            std::cout << "y is not 5 in switch\n";  
            break;  
    }  
  
    return 0;  
}

需要注意的是，C++17之前的标准不允许在if语句的条件部分进行变量初始化。从C++17开始，你可以像上面的示例那样在if语句的条件部分进行初始化。

另外，还要注意的是，在if语句的条件部分初始化的变量只在if语句的作用域内有效。这意味着你不能在if语句的外部访问这个变量。同样，在switch语句的case标签中，你也不能直接初始化变量（但你可以在case标签的代码块中初始化变量）。

动态内存分配

在C和C++中，动态内存分配都是编程的重要部分，允许程序在运行时根据需要分配和释放内存。虽然两者在语法和特性上有所不同，但基本概念是相似的。

C语言中的动态内存分配

在C语言中，我们主要使用malloc(), calloc(), realloc(), 和 free() 函数来进行动态内存分配和释放。

1. malloc()：分配指定字节数的内存，并返回指向该内存的指针。

int *ptr = (int*)malloc(sizeof(int) * 10); // 分配10个整数的内存

2. calloc()：与malloc()类似，但会初始化分配的内存为零。

int *ptr = (int*)calloc(10, sizeof(int)); // 分配10个整数并初始化为零

3. realloc()：调整已分配内存块的大小。

ptr = (int*)realloc(ptr, sizeof(int) * 20); // 将ptr指向的内存大小调整为20个整数

4. free()：释放之前分配的内存。

free(ptr); // 释放ptr指向的内存

C++中的动态内存分配

在C++中，除了可以使用C语言的函数外（尽管不推荐在C++中使用它们），还引入了new和delete操作符来进行动态内存分配和释放。

1. new：分配内存并调用对象的构造函数（如果有的话）。

int *ptr = new int[10]; // 分配10个整数的内存

对于对象，可以使用new来分配内存并直接初始化对象：

std::string *strPtr = new std::string("Hello, World!");

2. delete：释放之前使用new分配的内存，并调用对象的析构函数（如果有的话）。

delete[] ptr; // 释放ptr指向的内存（对于数组）

对于单个对象，使用不带[]的delete：

delete strPtr; // 释放strPtr指向的内存并调用std::string的析构函数

new/delete 和 malloc/free 的区别

new/delete 和 malloc/free 在C++中都是用于动态内存分配的，但它们之间存在一些重要的区别。以下是这些区别的主要点：

1. 所属语言：

   • malloc 和 free 是C语言中的函数，用于在堆上分配和释放内存。
   • new 和 delete 是C++中的运算符，用于在堆上分配和释放内存。

2. 构造函数和析构函数：

   • 使用 new 分配的对象会自动调用其构造函数（如果存在）。
   • 使用 delete 释放的对象会自动调用其析构函数（如果存在）。
   • malloc 和 free 则不会调用构造函数或析构函数。

3. 类型安全：

   • new 运算符返回的是对象的指针，具有类型信息，因此是类型安全的。
   • malloc 返回的是 void* 类型的指针，需要显式地进行类型转换，这可能导致类型不安全。

4. 异常安全性：

   • 如果 new 在分配内存时无法满足请求（如内存不足），它会抛出一个 bad_alloc 异常。这使得错误处理更加灵活。
   • malloc 在内存不足时返回 NULL，需要程序员显式地检查并处理这种情况。

5. 内存对齐：

   • new 运算符考虑了内存对齐的问题，确保对象按照其类型的要求进行对齐。
   • malloc 则不保证内存对齐，这可能导致某些硬件平台上的性能问题或错误。

6. 操作符重载：

   • 在C++中，new 和 delete 运算符可以被重载，以提供自定义的内存分配和释放策略。
   • malloc 和 free 不能被重载。

7. 初始化：

   • 使用 new 分配的对象可以使用初始化列表进行初始化。
   • malloc 分配的内存需要手动进行初始化（如果需要的话）。

8. 内存泄漏：

   • 无论是使用 new/delete 还是 malloc/free，如果忘记释放分配的内存，都可能导致内存泄漏。但是，由于C++提供了更强大的工具（如智能指针和RAII），使用 new/delete 时更容易管理内存泄漏问题。

在大多数情况下，建议在C++中使用 new/delete 而不是 malloc/free，因为 new/delete 提供了更好的类型安全性和异常安全性，并且与C++的面向对象特性更加契合。然而，在某些情况下（如与C库交互或需要更底层的内存管理时），可能仍然需要使用 malloc/free。

注意事项

• 在C++中，尽量使用new和delete，而不是C语言的内存分配函数，因为new和delete会自动调用构造函数和析构函数，有助于管理对象的生命周期。
• 在使用malloc()、calloc()、realloc()时，需要显式地转换返回的void*指针为所需的类型。但在C++中，使用new时不需要这样做。
• 使用new[]分配的内存必须使用delete[]来释放，而不能使用delete。同样，使用new分配的内存应该使用delete来释放，而不是delete[]。

原因如下：

• 构造函数和析构函数的调用：当使用new[]分配数组时，C++会为数组中的每个对象调用构造函数（如果需要）。同样地，当使用delete[]释放数组时，C++会为数组中的每个对象调用析构函数。如果你只使用delete而不是delete[]来释放数组，那么只有数组的第一个对象的析构函数会被调用，而其他对象的析构函数则不会被调用，这可能导致资源泄漏或其他未定义的行为。
• 内存管理：new[]不仅分配了数组中每个对象所需的内存，还分配了额外的内存来存储数组的大小或其他信息（尽管这通常是编译器实现的细节）。这些信息对于delete[]来说是必要的，因为它需要知道要调用多少个析构函数以及要释放多少内存。如果你只使用delete，编译器将不知道这些信息，从而导致不正确的内存管理。
• 类型安全：虽然这与必须使用delete[]的原因不直接相关，但值得注意的是，new[]和delete[]是专门为数组设计的，并且与C++的类型系统兼容。这有助于确保在释放内存时不会发生类型错误。
• 避免内存泄漏和未定义行为：未正确释放内存（如使用delete而不是delete[]）会导致内存泄漏和未定义行为。内存泄漏会浪费系统资源，而未定义行为可能导致程序崩溃或产生不可预测的结果。

• 忘记释放已分配的内存会导致内存泄漏，这是一个常见的编程错误。使用智能指针（如std::unique_ptr和std::shared_ptr）可以帮助自动管理内存，减少内存泄漏的风险。

定位放置

在C++中，new运算符有一个重载版本，称为定位放置new（placement new）。定位放置new允许程序员在预先分配的内存区域上构造对象，而不是让new自动分配内存。这在某些高级场景（如内存池管理、自定义内存分配策略或对象复用）中非常有用。

定位放置new的语法如下：

void* place = malloc(sizeof(T)); // 或者其他预先分配的内存
T* ptr = new(place) T(args); // 在place指向的内存上构造T类型的对象
// ... 使用ptr指向的对象 ...
ptr->~T(); // 显式调用析构函数
free(place); // 如果使用malloc分配的内存，需要显式释放

注意几个关键点：

1. malloc（或其他类似函数）用于预先分配内存。这不是必须的，但通常用于演示目的，因为new本身会分配内存。
2. new(place)语法用于在指定的内存地址place上构造对象。T(args)是传递给对象构造函数的参数列表。
3. 当你完成对象的使用后，必须显式调用对象的析构函数（在这个例子中是ptr->~T()），因为定位放置new不会自动调用析构函数或释放内存。
4. 如果你使用malloc分配了内存，那么还需要使用free来释放它。但是，如果你是在栈上或其他已管理的内存区域中预先分配了内存，则不需要这一步。

下面是一个简单的示例，展示了如何使用定位放置new：

#include <iostream>
#include <cstdlib> // 为了使用malloc和free

class MyClass {
public:
    MyClass(int value) : value_(value) {
        std::cout << "Constructing MyClass with value " << value_ << std::endl;
    }
    ~MyClass() {
        std::cout << "Destructing MyClass with value " << value_ << std::endl;
    }
    void printValue() const {
        std::cout << "Value: " << value_ << std::endl;
    }
private:
    int value_;
};

int main() {
    char buffer[sizeof(MyClass)]; // 预先分配的内存
    MyClass* ptr = new(buffer) MyClass(42); // 使用定位放置new构造对象
    ptr->printValue(); // 输出：Value: 42
    ptr->~MyClass(); // 显式调用析构函数
    // 注意：不需要释放buffer，因为它是栈上的数组
    return 0;
}

在这个示例中，我们在栈上预先分配了一个足够大的字符数组buffer来存储MyClass类型的对象。然后，我们使用定位放置new在buffer上构造了一个MyClass对象，并调用了它的printValue方法。最后，我们显式调用了析构函数来清理对象，但不需要（也不应该）释放buffer，因为它是在栈上分配的。