C++类和对象拷贝、初始化、构造析构顺序和静态成员总结

  • 开发
  • 11

文章目录

1.深拷贝和浅拷贝

在C++中，深拷贝（deep copy）和浅拷贝（shallow copy）是对象复制时的两种主要策略。理解这两种拷贝方式的区别对于编写正确的、避免潜在问题的代码非常重要。

1.浅拷贝（Shallow Copy）

浅拷贝只是复制了对象的指针或者值（如果对象是基本数据类型的话），而不去复制对象本身。对于包含动态分配内存（如使用new或malloc分配的内存）或指向其他对象的指针的类来说，浅拷贝可能会引发问题。

例如：

class MyClass {
public:
    int* ptr;
    MyClass(int value) {
        ptr = new int(value);
    }

    // 假设这是浅拷贝的拷贝构造函数
    MyClass(const MyClass& other) {
        ptr = other.ptr;  // 浅拷贝，只是复制了指针
    }

    ~MyClass() {
        delete ptr;
    }
};

在上面的例子中，如果创建了两个MyClass对象并使用浅拷贝的拷贝构造函数，那么两个对象都会指向同一块内存区域。当其中一个对象被销毁时，它会释放内存，而另一个对象则会尝试再次释放同一块内存，导致未定义行为（通常是程序崩溃）。

2.深拷贝（Deep Copy）

深拷贝会创建一个新的对象，并将原始对象的内容复制到新对象中。如果对象包含动态分配的内存或指向其他对象的指针，深拷贝会分配新的内存，并将原始数据复制到新内存中。

例如：

class MyClass {
public:
    int* ptr;
    MyClass(int value) {
        ptr = new int(value);
    }

    // 这是深拷贝的拷贝构造函数
    MyClass(const MyClass& other) {
        ptr = new int(*other.ptr);  // 深拷贝，分配了新的内存并复制了数据
    }

    ~MyClass() {
        delete ptr;
    }
};

在上面的例子中，即使创建了两个MyClass对象并使用深拷贝的拷贝构造函数，每个对象也会有自己的内存区域，并且当对象被销毁时，它们会释放自己的内存，而不会互相干扰。

3.注意事项
  • 在编写包含动态分配内存或指向其他对象的指针的类的拷贝构造函数和赋值运算符时，通常需要使用深拷贝来避免潜在的问题。
  • 默认情况下，C++编译器会提供浅拷贝的拷贝构造函数和赋值运算符。如果类需要深拷贝，你需要显式地定义它们。
  • 另一个常见的策略是使用智能指针（如std::unique_ptr或std::shared_ptr）来管理动态分配的内存。智能指针可以自动处理内存释放，从而避免许多与手动内存管理相关的问题。

2.初始化列表

在C++中，初始化列表（Initializer List）是构造函数的一部分，用于初始化类的成员变量。它允许我们以特定的顺序和方式初始化成员变量，这在某些情况下是必需的，特别是当成员变量是常量、引用或没有默认构造函数的对象时。

初始化列表在构造函数的冒号（:）之后和函数体的大括号（{}）之前声明。下面是初始化列表的基本用法示例：

class MyClass {
private:
    int x;
    const int y; // 常量成员变量，必须在构造函数的初始化列表中初始化
    std::string str; // 可以使用默认构造函数初始化，但也可以使用初始化列表

public:
    MyClass(int valX, int valY) : x(valX), y(valY) {
        // 初始化列表在这里
        // str 会使用默认构造函数初始化，除非在初始化列表中明确指定
    }

    MyClass(int valX, int valY, const std::string& valStr) : x(valX), y(valY), str(valStr) {
        // 初始化列表明确指定了str的初始化
    }

    // ... 其他成员函数 ...
};

在上面的例子中，MyClass有两个构造函数，它们都使用了初始化列表来初始化成员变量x和y。对于str，第一个构造函数没有显式地在初始化列表中初始化它，所以它会使用std::string的默认构造函数进行初始化。第二个构造函数则在初始化列表中明确指定了str的初始化值。

使用初始化列表而不是在构造函数体内赋值有以下几个优点：

  1. 效率：对于某些类型（如基本数据类型和POD类型），初始化列表通常比赋值更快，因为它避免了不必要的拷贝或移动操作。
  2. 必要性：对于常量成员、引用成员、没有默认构造函数的类类型的成员，必须在初始化列表中初始化。
  3. 初始化顺序：成员变量是按照它们在类中声明的顺序进行初始化的，而不是按照它们在初始化列表中出现的顺序。但是，在初始化列表中明确指定初始化顺序可以使代码更清晰。
  4. 常量性：对于常量成员，初始化列表是唯一的初始化方式。

请注意，即使对于可以在构造函数体内通过赋值初始化的成员，使用初始化列表通常也是一个好习惯，因为它可以提高代码的可读性和效率。

在C++中，类的成员（包括对象成员）的构造顺序和析构顺序是确定的，并且与它们在类定义中的声明顺序有关。这确保了依赖于特定初始化顺序的成员能够正确初始化，并在析构时以适当的顺序进行清理。

3.构造顺序和析构顺序

1.构造顺序
  • 构造函数在创建对象时被调用。
  • 对象的构造顺序总是按照它们在类定义中声明的顺序进行。
  • 如果类有基类，那么基类的构造函数会首先被调用，然后是成员对象的构造函数，最后才是类本身的构造函数体（如果有的话）。
  • 如果一个类有多个基类，则基类的构造顺序是由它们在派生类列表中的声明顺序决定的，而不是它们在继承层次结构中的层次顺序。
2.析构顺序
  • 析构函数在对象生命周期结束时被调用，这通常发生在对象离开其作用域时，或者是被delete运算符显式删除时。
  • 析构顺序与构造顺序相反。首先执行类本身的析构函数体（如果有的话），然后是成员对象的析构函数，最后是基类的析构函数。
  • 如果有多个基类，则基类的析构顺序与它们在派生类列表中的声明顺序相反。
3.示例
#include <iostream>

class Base {
public:
    Base() { std::cout << "Base constructor\n"; }
    ~Base() { std::cout << "Base destructor\n"; }
};

class Member {
public:
    Member() { std::cout << "Member constructor\n"; }
    ~Member() { std::cout << "Member destructor\n"; }
};

class Derived : public Base {
    Member m;
public:
    Derived() { std::cout << "Derived constructor\n"; }
    ~Derived() { std::cout << "Derived destructor\n"; }
};

int main() {
    Derived d;
    return 0;
}

输出将是：

Base constructor
Member constructor
Derived constructor
Derived destructor
Member destructor
Base destructor

在这个例子中，首先调用了基类Base的构造函数，然后调用了成员对象m（类型为Member）的构造函数，最后调用了派生类Derived的构造函数。在main函数结束时，析构顺序相反：首先调用Derived的析构函数，然后调用成员对象m的析构函数，最后调用基类Base的析构函数。

4.静态成员

在C++中，静态成员（包括静态数据成员和静态成员函数）是类的一部分，但与类的任何特定对象实例无关。静态成员在类的所有实例之间共享，并且可以在没有创建类对象的情况下直接通过类名进行访问。

1.静态数据成员

静态数据成员在类的所有对象之间共享一个存储位置。静态数据成员在类定义中声明，但在类定义外部初始化。它们不能在类内部进行初始化（除了用常量表达式初始化静态整型或枚举类型的静态成员）。

2.示例
#include <iostream>

class MyClass {
public:
    // 静态数据成员声明
    static int count;

    MyClass() {
        // 递增静态数据成员以跟踪创建的对象数量
        ++count;
    }

    ~MyClass() {
        // 递减静态数据成员（可选，但通常用于调试或统计）
        --count;
    }

    // 静态成员函数声明
    static void printCount() {
        std::cout << "Number of objects created: " << count << std::endl;
    }
};

// 静态数据成员在类定义外部初始化
int MyClass::count = 0;

int main() {
    MyClass obj1, obj2, obj3;
    MyClass::printCount(); // 输出：Number of objects created: 3

    return 0;
}

在这个例子中，MyClass有一个静态数据成员count，它用于跟踪创建的MyClass对象的数量。静态成员函数printCount用于输出count的值。注意，静态数据成员count在类定义外部初始化，并且只能初始化一次。

3.静态成员函数

静态成员函数不与类的任何对象实例关联，因此它们没有this指针。静态成员函数只能访问静态成员（包括静态数据成员和其他静态成员函数），而不能访问非静态成员。

4.示例
class MyClass {
public:
    static void staticFunc() {
        // 只能访问静态成员
        std::cout << "This is a static function.\n";
    }

    void nonStaticFunc() {
        // 可以访问静态和非静态成员
        std::cout << "This is a non-static function.\n";
        // MyClass::staticFunc(); // 也可以这样调用静态函数
    }
};

int main() {
    MyClass::staticFunc(); // 直接通过类名调用静态函数

    MyClass obj;
    obj.nonStaticFunc(); // 通过对象实例调用非静态函数
    // obj.staticFunc(); // 错误！不能通过对象实例调用静态函数

    return 0;
}

在这个例子中，MyClass有一个静态成员函数staticFunc和一个非静态成员函数nonStaticFunc。静态函数staticFunc只能通过类名来调用，而非静态函数nonStaticFunc可以通过对象实例来调用。尝试通过对象实例来调用静态函数会导致编译错误。

5.补充

静态成员（包括静态数据成员和静态成员函数）可以在类外调用。由于静态成员与类的任何特定实例无关，因此它们可以通过类名直接访问，而无需创建类的对象。

对于静态数据成员，你可以在类外通过类名来访问或修改它。但是，静态数据成员必须在类外进行初始化，通常是在类的定义之后。

对于静态成员函数，你可以通过类名来调用它们，就像调用普通的非成员函数一样。

以下是一个示例，展示了如何在类外调用静态成员：

#include <iostream>

class MyClass {
public:
    // 静态数据成员声明
    static int count;

    // 静态成员函数声明
    static void printCount() {
        std::cout << "Number of objects created: " << count << std::endl;
    }

    // 构造函数，用于更新静态数据成员
    MyClass() {
        ++count;
    }

    // 析构函数，这里不用于修改count，但为了完整性列出
    ~MyClass() {
        // 在实际使用中，析构函数通常不用于修改静态成员
    }
};

// 静态数据成员在类外初始化
int MyClass::count = 0;

int main() {
    // 创建对象
    MyClass obj1;
    MyClass obj2;

    // 在类外通过类名调用静态成员函数
    MyClass::printCount(); // 输出：Number of objects created: 2

    // 在类外直接访问静态数据成员（但通常不建议这样做，除非有明确的理由）
    std::cout << "Direct access to static member: " << MyClass::count << std::endl; // 输出：Direct access to static member: 2

    return 0;
}

在这个示例中，MyClass::printCount() 和 MyClass::count 都是在类外通过类名 MyClass 访问的静态成员。注意，尽管可以直接访问静态数据成员 MyClass::count，但在实践中，通常更推荐通过静态成员函数（如 printCount）来访问和修改它们，因为这可以提高封装性和代码的可读性。

阅读全部

相关推荐

  1. C++类和对象拷贝、初始化、构造析构顺序和静态成员总结

    2024-06-06 08:12:04       12 阅读

  2. C++学习笔记“类和对象”；对象的初始化和清理，构造函数和析构函数，初始化列表，静态成员

    2024-06-06 08:12:04       10 阅读

  8. 【c++】-对象的初始化-构造函数和析构函数区别联系-总结

    2024-06-06 08:12:04       17 阅读

最近更新

  4. TCP协议是安全的吗?

    2024-06-06 08:12:04       16 阅读

  12. 阿里云服务器执行yum，一直下载docker-ce-stable失败

    2024-06-06 08:12:04       16 阅读

  13. 【Python教程】压缩PDF文件大小

    2024-06-06 08:12:04       15 阅读

  18. 通过文章id递归查询所有评论（xml）

    2024-06-06 08:12:04       18 阅读

热门阅读

  2. arm系统中双网卡共存问题

    2024-06-06 08:12:04       12 阅读

  4. 【DevOps】网络安全进阶之路：打造更安全、更可靠的网站

    2024-06-06 08:12:04       9 阅读

  6. stm32和esp32硬件资源上有什么区别 哪个更适合初学者

    2024-06-06 08:12:04       17 阅读

  7. Transformer的Encoder和Decoder之间的交互

    2024-06-06 08:12:04       11 阅读

  10. MyBatis二、搭建 MyBatis

    2024-06-06 08:12:04       9 阅读

  17. 介绍 TensorFlow 的基本概念和使用场景

    2024-06-06 08:12:04       9 阅读

  20. Oracle数据库启动时必需开启的后台服务有哪些

    2024-06-06 08:12:04       11 阅读

  21. 24个数学符号大小写读法及中文注音

    2024-06-06 08:12:04       9 阅读

  22. 统一返回响应

    2024-06-06 08:12:04       9 阅读

  29. LeetCode199.二叉树的右视图

    2024-06-06 08:12:04       9 阅读