万字详解C++类的初始化的五种语义

最新推荐文章于 2025-09-30 11:55:45 发布
原创 最新推荐文章于 2025-09-30 11:55:45 发布 · 962 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

五种语义概述

1、析构函数
2、拷贝构造函数
3、拷贝赋值运算符
4、移动构造函数
5、移动赋值运算符

析构函数

析够函数是一个类的生命周期结束时候，自动调用的终结函数，主要用于资源的释放等。
析构函数demo

#include <iostream>
#include <cstdio>

class MyClass
{
public:
    MyClass()
    {
        NumCount = new int(10);
        printf("this is %s class constructor\n", __FUNCTION__);
    }
    ~MyClass()
    {
        delete NumCount;
        NumCount = nullptr;
        printf("this is %s class destructor\n", __FUNCTION__);
    }

private:
    int *NumCount = nullptr;
};

int main()
{
    MyClass obj;
    return 0;
}

运行效果

this is MyClass class constructor
this is ~MyClass class destructor

如果我们修改以下代码

#include <iostream>
#include <cstdio>

class MyClass
{
public:
    MyClass()
    {
        NumCount = new int(3);
        NumCount[0] = 0;
        NumCount[1] = 1;
        NumCount[2] = 2;
        printf("this is %s class constructor\n", __FUNCTION__);
    }

    // ~MyClass()
    // {
    //     delete NumCount;
    //     NumCount = nullptr;
    //     printf("this is %s class destructor\n", __FUNCTION__);
    // }

public:
    int *GetPtr()
    {
        return NumCount;
    }

private:
    int *NumCount = nullptr;
};

int main()
{
    int * ptr = nullptr;
    {
        MyClass obj;
        ptr = obj.GetPtr();
    }
    printf("ptr[0] : %d\n", ptr[0]);
    printf("ptr[1] : %d\n", ptr[1]);
    printf("ptr[2] : %d\n", ptr[2]);
    return 0;
}

运行结果

this is MyClass class constructor
ptr[0] : 0
ptr[1] : 1
ptr[2] : 2

可以看到在注释掉MyClass的析构函数后，MyClass的生命周期已经结束了，但是NumCount的资源未被释放掉。这种资源泄漏的危害是十分巨大的。

当我们注释掉MyClass的析构函数，编译器会自动生成默认的析够函数，其语义如下：

~MyClass() = default;

默认的析构函数只能释放栈上面的资源，对于手动分配的堆上的资源是无法释放的。因此在写一个类的时候，一定要显式声明出其对应的析构函数。

拷贝构造函数

拷贝构造函数即用一个已有对象初始化另一个同类型对象。

MyClass a;         // 普通构造
MyClass b = a;     // 调用拷贝构造
MyClass c(a);      // 同样调用拷贝构造

拷贝构造demo

#include <iostream>
#include <cstdio>

class MyClass
{
public:
    MyClass() //构造函数
    {
        printf("this is %s class constructor\n", __FUNCTION__);
    }

    MyClass(const MyClass &) //拷贝构造函数
    {
        printf("this is %s class copy construction \n", __FUNCTION__);
    }

    ~MyClass() //析构函数
    {
        printf("this is %s class destructor\n", __FUNCTION__);
    }

};

int main()
{
    MyClass obj1;
    MyClass obj2 = obj1;
    MyClass obj3(obj1);
    return 0;
}

运行效果

this is MyClass class constructor
this is MyClass class copy construction 
this is MyClass class copy construction 
this is ~MyClass class destructor
this is ~MyClass class destructor
this is ~MyClass class destructor

可以看到obj2和obj3都是调用拷贝构造去创建的。现在我们将显式的拷贝构造变成默认的。即不写拷贝构造，或者将拷贝构造写成default。

#include <iostream>
#include <cstdio>

class MyClass
{
public:
    MyClass() //构造函数
    {
        a = 1;
        printf("this is %s class constructor\n", __FUNCTION__);
    }

    MyClass(const MyClass &) = default;// 默认构造函数显式声明，等同将这句代码删掉

    ~MyClass() //析构函数
    {
        printf("this is %s class destructor\n", __FUNCTION__);
    }

public:
    int GetData()
    {
        return a;
    }

    void SetData(const int &data)
    {
        a = data;
    }

private:
    int a = 0;

};

int main()
{
    MyClass obj1; //构造函数
    printf("obj1 a : %d\n", obj1.GetData());

    MyClass obj2 = obj1; //拷贝构造
    printf("obj2 a : %d\n", obj2.GetData());

    obj1.SetData(3);
    MyClass obj3(obj1); //拷贝构造
    printf("obj3 a : %d\n", obj3.GetData());

    return 0;
}

运行结果

this is MyClass class constructor
obj1 a : 1
obj2 a : 1
obj3 a : 3
this is ~MyClass class destructor
this is ~MyClass class destructor
this is ~MyClass class destructor

obj1调用构造函数将a初始化为1
obj2调用拷贝构造,将obj1中的a数值拷贝给了obj2中的a,所以obj2中的a = 1
obj1通过SetData接口将a设置为3
obj3调用拷贝构造,将obj1中的a数值拷贝给了obj3中的a,所以obj3中的a = 3

现在我们修改一下代码：

#include <iostream>
#include <cstdio>

class MyClass
{
public:
    MyClass() //构造函数
    {
        NumCount = new int(3);
        printf("this is %s class constructor\n", __FUNCTION__);
    }

    MyClass(const MyClass &) = default;

    ~MyClass() //析构函数
    {
        delete NumCount;
        NumCount = nullptr;
        printf("this is %s class destructor\n", __FUNCTION__);
    }

    int * GetPtr()
    {
        return NumCount;
    }

private:
    int *NumCount = nullptr;

};

int main()
{
    MyClass obj1; //构造函数
    printf("obj1 NumCount : %p\n", obj1.GetPtr());

    MyClass obj2 = obj1; //拷贝构造
    printf("obj2 NumCount : %p\n", obj2.GetPtr());

    MyClass obj3(obj1); //拷贝构造
    printf("obj3 NumCount : %p\n", obj3.GetPtr());

    return 0;
}

运行结果

this is MyClass class constructor
obj1 NumCount : 0x953eb0
obj2 NumCount : 0x953eb0
obj3 NumCount : 0x953eb0
this is ~MyClass class destructor
free(): double free detected in tcache 2
已放弃 (核心已转储)

可以看到三个对象中的NumCount地址是一样的，到在通过默认拷贝构造中，对于分配在堆上面的成员变量即NumCount发生的是浅拷贝，obj2,obj3只是将obj1中的NumCount地址拷贝了，并没有分配其新的空间。导致在析构时候对同一个地址进行**多次释放(又称 Double Free)**从而使得程序挂掉。

我们重新实现拷贝构造函数，实现深拷贝。

#include <iostream>
#include <cstdio>

class MyClass
{
public:
    MyClass() //构造函数
    {
        NumCount = new int(size);
        NumCount[0] = 0;
        NumCount[1] = 1;
        NumCount[2] = 2;
        printf("this is %s class constructor\n", __FUNCTION__);
    }

    MyClass(const MyClass &other)
    {
        if (NumCount == nullptr) {
            NumCount = new int(other.size);
            for (int i =  0; i < size; i++) {
                NumCount[i] = other.NumCount[i];
            }
        }
    }

    ~MyClass() //析构函数
    {
        delete[] NumCount;
        NumCount = nullptr;
        printf("this is %s class destructor\n", __FUNCTION__);
    }

    int * GetPtr()
    {
        return NumCount;
    }

private:
    int size = 3;
    int *NumCount = nullptr;

};

int main()
{
    MyClass obj1; //构造函数
    printf("obj1 NumCount : %p\n", obj1.GetPtr());
    printf("obj1 NumCount[0] = %d\n", obj1.GetPtr()[0]);
    printf("obj1 NumCount[1] = %d\n", obj1.GetPtr()[1]);
    printf("obj1 NumCount[2] = %d\n", obj1.GetPtr()[2]);

    MyClass obj2 = obj1; //拷贝构造
    printf("obj2 NumCount : %p\n", obj2.GetPtr());
    printf("obj2 NumCount[0] = %d\n", obj2.GetPtr()[0]);
    printf("obj2 NumCount[1] = %d\n", obj2.GetPtr()[1]);
    printf("obj2 NumCount[2] = %d\n", obj2.GetPtr()[2]);

    MyClass obj3(obj1); //拷贝构造
    printf("obj3 NumCount : %p\n", obj3.GetPtr());
    printf("obj3 NumCount[0] = %d\n", obj3.GetPtr()[0]);
    printf("obj3 NumCount[1] = %d\n", obj3.GetPtr()[1]);
    printf("obj3 NumCount[2] = %d\n", obj3.GetPtr()[2]);

    return 0;
}

运行结果

this is MyClass class constructor
obj1 NumCount : 0x17a3eb0
obj1 NumCount[0] = 0
obj1 NumCount[1] = 1
obj1 NumCount[2] = 2
obj2 NumCount : 0x17a42e0
obj2 NumCount[0] = 0
obj2 NumCount[1] = 1
obj2 NumCount[2] = 2
obj3 NumCount : 0x17a4300
obj3 NumCount[0] = 0
obj3 NumCount[1] = 1
obj3 NumCount[2] = 2
this is ~MyClass class destructor
this is ~MyClass class destructor
this is ~MyClass class destructor

可以看到三个对象中的NumCount指针都不一样，NumCount中的数据完全拷贝过来了，程序也没有异常。因此在写构造函数的时候需要注意：
1、如果对象都是在栈上分配的可以不写拷贝构造函数。或者显式的默认声明出来

MyClass(const MyClass &) = default;

2、如果这个类不会使用拷贝构造

    MyClass obj2 = obj1; //拷贝构造
    MyClass obj3(obj1); //拷贝构造

可设置为delete

MyClass(const MyClass &) = delete;

这样在编译时候既可以检查出报错

code1.cpp: In function ‘int main()’:
code1.cpp:39:20: error: use of deleted function ‘MyClass::MyClass(const MyClass&)’
     MyClass obj2 = obj1; //拷贝构造
                    ^
code1.cpp:16:5: note: declared here
     MyClass(const MyClass &) = delete;
     ^
code1.cpp:40:22: error: use of deleted function ‘MyClass::MyClass(const MyClass&)’
     MyClass obj3(obj1); //拷贝构造
                      ^
code1.cpp:16:5: note: declared here
     MyClass(const MyClass &) = delete;

拷贝赋值运算符

拷贝赋值运算符是 C++ 中用于把一个对象的值赋给另一个已经存在的对象的运算符函数。
上面我们讲了拷贝构造如下：

    MyClass obj2 = obj1; //拷贝构造
    MyClass obj3(obj1); //拷贝构造

那么拷贝赋值运算符是下述方式的构造

    MyClass obj2; 拷贝构造
   
    MyClass obj3; 
    obj3 = obj2； 拷贝赋值运算符！！！！！！

拷贝赋值运算符demo

#include <iostream>
#include <cstdio>

class MyClass
{
public:
    MyClass()                                       // 构造函数
    {
        Count = 1;
        printf("this is %s class constructor\n", __FUNCTION__);
    }

    MyClass(const MyClass &) = delete;              // 禁用拷贝构造
    MyClass& operator=(const MyClass &) = default;  // 使用默认拷贝赋值运算符

    ~MyClass()                                      // 析构函数
    {
        printf("this is %s class destructor\n", __FUNCTION__);
    }

public:
    void SetCount(const int &num)
    {
        Count = num;
    }

    int GetCount()
    {
        return Count;
    }

private:
    int Count = 0;

};

int main()
{
    MyClass obj1; //构造函数
    MyClass obj2; //拷贝构造

    printf("obj1 Count : %d\n", obj1.GetCount());
    printf("obj2 Count : %d\n", obj2.GetCount());

    obj1.SetCount(6);
    obj2 = obj1;
    printf("obj2 Count : %d\n", obj2.GetCount());

    return 0;
}

运行结果

this is MyClass class constructor
this is MyClass class constructor
obj1 Count : 1
obj2 Count : 1
obj2 Count : 6
this is ~MyClass class destructor
this is ~MyClass class destructor

现在我们修改一下Count的类型

#include <iostream>
#include <cstdio>

class MyClass
{
public:
    MyClass() //构造函数
    {
        if (Count == nullptr) {
            Count = new int(3);
        }
        printf("this is %s class constructor\n", __FUNCTION__);
    }

    MyClass(const MyClass &) = delete;  //拷贝构造

    MyClass& operator=(const MyClass &other) = default;

    ~MyClass() //析构函数
    {
        delete Count;
        Count = nullptr;
        printf("this is %s class destructor\n", __FUNCTION__);
    }

public:
    void SetCount(const int &num)
    {
        *Count = num;
    }

    int *GetCount()
    {
        return Count;
    }

private:
    int * Count = nullptr;

};

int main()
{
    MyClass obj1; //构造函数
    MyClass obj2; //构造函数

    printf("obj1 Count : %d, addr : %p\n", *obj1.GetCount(), obj1.GetCount());
    printf("obj2 Count : %d, addr : %p\n", *obj2.GetCount(), obj2.GetCount());

    obj1.SetCount(6);
    obj2 = obj1;
    printf("obj2 Count : %d, addr : %p\n", *obj2.GetCount(), obj2.GetCount());

    return 0;
}

运行结果

this is MyClass class constructor
this is MyClass class constructor
obj1 Count : 3, addr : 0x893eb0
obj2 Count : 3, addr : 0x8942e0
obj2 Count : 6, addr : 0x893eb0
this is ~MyClass class destructor
free(): double free detected in tcache 2
已放弃 (核心已转储)

在创建obj1和obj2的时候，可以看到 obj1->Count = 0x893eb0, obj2->Count = 0x8942e0;在执行完拷贝赋值运算后,obj2->Count的地址变成了obj1->Count。也就是说执行完拷贝赋值运算obj2obj1中的成员执行了浅拷贝。只是将obj1->Count中的地址拷贝过来。obj1和obj2访问的是同一块空间，此时同时obj2中的Count空间无指针指向，出现了内存泄漏。同时在这两个对象生命周期结束时，执行析构函数会出现，出现“double free” 导致程序直接挂掉。

因此在涉及到分配在堆上的内存时，拷贝赋值运算符要格外注意。下面是修正版本

#include <iostream>
#include <cstdio>

class MyClass
{
public:
    MyClass() //构造函数
    {
        if (Count == nullptr) {
            Count = new int(3);
        }
        printf("this is %s class constructor\n", __FUNCTION__);
    }

    MyClass(const MyClass &) = delete;  //拷贝构造

    MyClass& operator=(const MyClass &other) //拷贝赋值运算符
    {
        printf("this is %s class copy assignment operator \n", __FUNCTION__);
        if (this == &other) {  // 自赋值保护
            return *this;
        }

        delete Count; //释放构造函数分配的资源
        Count = nullptr;

        Count = new int(*other.Count);
        return *this; //注意返回的是当前对象不是Count ！！！！！！！
    }

    ~MyClass() //析构函数
    {
        delete Count;
        Count = nullptr;
        printf("this is %s class destructor\n", __FUNCTION__);
    }

public:
    void SetCount(const int &num)
    {
        *Count = num;
    }

    int *GetCount()
    {
        return Count;
    }

private:
    int * Count = nullptr;

};

int main()
{
    MyClass obj1; //构造函数
    MyClass obj2; //构造函数

    printf("obj1 Count : %d\n", *obj1.GetCount());
    printf("obj2 Count : %d\n", *obj2.GetCount());

    obj1.SetCount(6);
    obj2 = obj1;
    printf("obj2 Count : %d\n", *obj2.GetCount());

    return 0;
}

运行结果

this is MyClass class constructor
this is MyClass class constructor
obj1 Count : 3
obj2 Count : 3
this is operator= class copy assignment operator 
obj2 Count : 6
this is ~MyClass class destructor
this is ~MyClass class destructor

移动构造函数

移动构造函数是 C++11 引入的一个特殊构造函数，用来从另一个对象“窃取”资源，而不是拷贝资源，从而提升性能。

上诉的拷贝构造和拷贝赋值运算符中都讲述了double free问题移动构造函数中也和上述一样，再使用默认移动构造函数时候，对于分配在堆上的数据，只会使用浅拷贝，导致出现double free。

#include <iostream>
#include <cstdio>

class MyClass
{
public:
    MyClass() //构造函数
    {
        if (Count == nullptr) {
            Count = new int(3);
        }
        printf("this is %s class constructor\n", __FUNCTION__);
    }

    MyClass(const MyClass &) = delete;  //拷贝构造
    MyClass& operator=(const MyClass &other) = delete; //拷贝赋值运算符
    MyClass(MyClass &&other) = default; //移动构造函数

    ~MyClass() //析构函数
    {
        delete Count;
        Count = nullptr;
        printf("this is %s class destructor\n", __FUNCTION__);
    }

public:
    void SetCount(const int &num)
    {
        *Count = num;
    }

    int *GetCount()
    {
        return Count;
    }

private:
    int * Count = nullptr;

};

int main()
{
    MyClass obj1; //构造函数
    printf("obj1 Count : %d, addr : %p\n", *obj1.GetCount(), obj1.GetCount());
    obj1.SetCount(6);
    MyClass obj2 = std::move(obj1); //构造函数
    printf("obj2 Count : %d, addr : %p\n", *obj2.GetCount(), obj2.GetCount());

    return 0;
}

运行结果

this is MyClass class constructor
obj1 Count : 3, addr : 0xc0feb0
obj2 Count : 6, addr : 0xc0feb0
this is ~MyClass class destructor
free(): double free detected in tcache 2
已放弃 (核心已转储)

可以看到obj1->Count和obj2->Count的指针完全一样，在析构的时候出现double free。导致程序挂掉。
在类中如果有使用裸指针的话，一定要注意移动构造函数。下面我们修正上述的问题

#include <iostream>
#include <cstdio>

class MyClass
{
public:
    MyClass() //构造函数
    {
        if (Count == nullptr) {
            Count = new int(3);
        }
        printf("this is %s class constructor\n", __FUNCTION__);
    }

    MyClass(const MyClass &) = delete;  //拷贝构造
    MyClass& operator=(const MyClass &other) = delete; //拷贝赋值运算符
    MyClass(MyClass &&other)
    {
        Count = other.Count;
        other.Count = nullptr;
    }
	
    ~MyClass() //析构函数
    {
    	//C++ 标准规定：delete nullptr; 是安全的，不会出错。 可以不判断是否为nullptr
        if(Count == nullptr)
        {
            delete Count;
            Count = nullptr;
        }
        printf("this is %s class destructor\n", __FUNCTION__);
    }

public:
    void SetCount(const int &num)
    {
        *Count = num;
    }

    int *GetCount()
    {
        return Count;
    }

private:
    int * Count = nullptr;

};

int main()
{
    MyClass obj1; //构造函数
    printf("obj1 Count : %d, addr : %p\n", *obj1.GetCount(), obj1.GetCount());
    obj1.SetCount(6);
    MyClass obj2 = std::move(obj1);
    printf("obj1 addr : %p\n", obj1.GetCount());
    printf("obj2 Count : %d, addr : %p\n", *obj2.GetCount(), obj2.GetCount());

    return 0;
}

运行结果

this is MyClass class constructor
obj1 Count : 3, addr : 0x51ceb0
obj1 addr : (nil)
obj2 Count : 6, addr : 0x51ceb0
this is ~MyClass class destructor
this is ~MyClass class destructor

可以看到obj1->Count和obj2->Count的指针完全一样，在move obj2对象后obj2->Count被设置为了nullptr,避免了double free。

穿插一个小知识点

struct MyStringHolder {
    std::string s;

    // 方式1：初始化列表
    MyStringHolder(MyStringHolder&& other)
        : s(std::move(other.s)) {}  // 直接调用string的移动构造

    // 方式2：构造体内赋值
    MyStringHolder(MyStringHolder&& other) {
         s = std::move(other.s);  // 先默认构造s，再移动赋值
     }
};


struct Demo {
    std::string s = "world";  // 默认初始值

    // 情况1：用初始化列表 → 忽略默认初始值，直接构造为 "Hello"
    Demo() : s("Hello") {}

    // 情况2：没用初始化列表 → 用默认初始值 "world"
    // Demo() {}

    // 情况3：没默认初始值也没初始化列表 → s 默认构造为空串
    // std::string s; Demo() {}
};

因此在初始化类的成员变量时候，尽量使用初始化成员列表方式

移动赋值运算符

移动赋值运算符是 C++ 中用于把 一个对象的资源搬过来而不是拷贝一份 的运算符函数。
上面我们讲了移动构造如下：

    MyClass obj1;
    MyClass obj2 = std::move(obj1);

那么移动赋值运算符是下述方式

    MyClass obj1; 
    MyClass obj2; 
    obj2 = std::move(obj3);

移动赋值运算：参考上面举的例子这里就不举double free 这种例子了。

移动赋值运算符运算符demo

#include <iostream>
#include <cstring>

class MyClass
{
private:
    char *data;

public:
    MyClass(const char *str = "")
    {
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }

    ~MyClass()
    {
        delete[] data;
    }

    // 拷贝构造
    MyClass(const MyClass &other) = delete;
    // 移动构造
    MyClass(MyClass &&other) = delete;
    // 拷贝赋值
    MyClass &operator=(const MyClass &other) = delete;

    // 移动赋值
    MyClass &operator=(MyClass &&other) noexcept
    {
        if (this != &other)
        {
            delete[] data;
            data = other.data;
            other.data = nullptr;
        }
        printf("Move assignment\n");
        return *this;
    }

    void print()
    {
        printf("data : %s\n", (data ? data : "null"));
    };
};

int main()
{
    MyClass a("Hello");
    MyClass b("World");

    b = std::move(a); // 调用移动赋值
    a.print();
    b.print();
}

运行结果

Move assignment
data : null
data : Hello

总结

类型范式使用场景
析构~MyClass()对象生命周期结束
拷贝构造MyClass(const MyClass &)MyClass a; MyClass b = a; MyClass c(a);
拷贝赋值运算符MyClass& operator=(const MyClass &other)MyClass obj2; MyClass obj3; obj3 = obj2；
移动构造MyClass(MyClass &&other)MyClass obj1; MyClass obj2 = std::move(obj1);
移动赋值运算符MyClass &operator=(MyClass &&other)MyClass a; MyClass b; b = std::move(a);

–结语–
感谢您的阅读，如有问题可以私信或评论区交流。
^ _ ^

【028】深入理解C++ 类和对象：构造、析构、拷贝构造、初始化列表 详解（最全讲解）
Lion_Long的博客
06-15 1229
C++构造函数是一种特殊的成员函数，用于初始化类的对象。它们具有与类名称相同的名称，并且不返回任何值（包括void）。它们可以带有参数或不带参数，根据需要进行重载。当创建一个类对象时，构造函数会被自动调用。如果没有定义构造函数，则编译器会提供一个默认的构造函数。默认构造函数不执行任何操作，但确保对象被正确初始化。在构造函数中，可以对数据成员进行初始化、分配内存空间和执行其他必要的操作类实例化对象的时候，系统自动调用构造函数，完成对象的初始化。
C++：类的简单介绍（六）——初始化列表
2301_76445610的博客
02-05 1465
1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)引用成员变量const成员变量自定义类型成员(且该类没有默认构造函数时)除了以上三类，其他的成员变量在初始化列表或者在函数体（{}内部的）的使用影响都不是很大！但是还是建议使用初始化列表。
类初始化（C++）
chen_hard的博客
08-16 1965
语法： 初始化列表完成的是对类"成员变量"初始化工作，而构造函数函数体中是赋值操作 成员变量在初始化列表中只能出现一次，真正的初始化次序是按照成员变量在类中声明的次序进行初始化 尽量避免使用成员来初始化成员 必须在初始化列表位置初始化的成员 const类型的成员 引用类型的成员 类类型对象(并且类类型对象具有无参的构造函数&&没有无参和全缺省的构造函数) 注意: 初始化列表是构造函数的特性 用户没有显式给出时，初始化列表仍旧存在，只不过编译器会对成员变量进行默认的初
c++类的初始化
sun13047140038的博客
09-15 2168
成员初始化列表是在构造函数的定义中使用的特殊语法，用于初始化类的成员变量。通过成员初始化列表，可以在构造函数开始执行之前对成员变量进行初始化，以提高效率并确保正确的初始化顺序。通过这两个步骤，您可以在C++中初始化类的对象并确保成员变量的正确初始化。构造函数和成员初始化列表的使用可以根据类的需要来选择，以满足对象的初始化要求。在C++中，类的初始化通常分为两个步骤：构造函数的调用和成员初始化列表的使用。// 带参数的构造函数，使用成员初始化列表初始化成员变量。
C++ 类对象初始化
鲸落博客
05-01 1998
当创建一个类的实例时，如果没有定义构造函数，系统会自动生成一个无参构造函数，并自动初始化成员变量。内置类型的变量（如int、double、指针等）会被初始化为一个未定义的值，而自定义类型的变量（如类、结构体）会调用默认构造函数进行初始化。
C++学习——类的初始化
热门推荐
zxr916的博客
06-20 1万+
文章目录1.类通过构造函数进行数据成员初始化2.类成员初始化方式？3.什么情况下必须使用列表初始化？4.为什么用列表初始化成员变量会快一些？5.派生类构造函数的执行顺序 1.类通过构造函数进行数据成员初始化 一般来说，类中的数据成员是私有的，不能通过对象共有访问的方式对数据成员赋初始值。一般来说，构造函数就是用来用来在创建对象时初始化对象， 为对象数据成员赋初始值。 构造函数是类的一种特殊成员函数，不需要人为调用，而是在建立对象时自动被执行。 2.类成员初始化方式？ 赋值初始化，通过在函数体内进行赋值初始化
【C++】使用类，一定有类的初始化
DMLearner的博客
05-17 256
访问控制属性包括：公有类型（public），私有类型（private）和保护类型（protected）虽然，不设置访问控制属性的默认是私有类型。比如变量 pr 是私有类型，外部访问会报错。还有。
40、C++ 类成员访问与初始化详解
rr23456的博客
06-18 106
本文详细解析了C++中类成员的访问规则和初始化过程，涵盖类成员访问基础、友元权限与声明、受保护成员的访问条件、虚函数访问控制、多重继承访问策略、嵌套类特性以及对象初始化方式等内容。通过示例代码和流程图，全面梳理了构造函数初始化顺序、默认初始化、显式初始化和列表初始化等关键知识点，帮助开发者深入理解并正确应用C++类机制。
28、C++ 初始化规则与聚合初始化详解
rr23456的博客
06-06 41
本文详细解析了C++中的初始化规则，包括零初始化、默认初始化、值初始化等多种初始化方式，同时深入探讨了聚合初始化的语法和规则。还涵盖了非静态成员作为默认参数的限制、虚函数调用中的默认参数行为等重要知识点。通过示例代码和分类总结，帮助开发者全面理解C++初始化机制，提升程序的健壮性和可维护性。
C++派生类初始化基类成员详解
"C++编程中的初始化基类成员是重要的概念，因为构造函数不能被继承，派生类必须通过显式调用基类的构造函数来初始化基类成员。理解这一机制对于有效地创建和管理类层次结构至关重要。" 在C++编程中，基类和派生类的...
C++初始化与清除机制详解
此外，初始化与清除还涉及复制控制的三大函数（拷贝构造函数、拷贝赋值运算符、析构函数）以及C++11引入的移动语义（移动构造函数和移动赋值运算符）。当类管理了动态资源时，必须显式定义这些函数以实现深拷贝或...
C++ 类的初始化列表
tianyexing2008的博客
01-26 1105
return 0;因为 const 类型的变量是常量，必须有初始化值，且后续不可以进行修改操作。return 0;和上面的错误一样，引用类型的变量必须初始化。
C++中的对象初始化
转载和创作优秀的博客
01-14 3443
当对象在创建时获得了一个特定的值，我们说这个对象被初始化。初始化不是赋值，初始化的含义是创建变量赋予其一个初始值，而赋值的含义是把当前值擦除，而以一个新值来替代。对象初始化可以分为默认初始化、直接初始化、拷贝初始化以及值初始化。 // （1）默认初始化 int i1;//默认初始化，在函数体之外(初始化为0) int f(void) { int i2;//不被初始化，如果使用此对象则报错 } string empty;//empty非显示的初始化为一个空串，调用的是默认
C++初始化列表
无名
01-05 1410
与其他函数不同，构造函数除了有名字，参数列表和函数体之外，还可以有初始化列表，初始化列表以冒号开头，后跟一系列以逗号分隔的初始化字段。 class foo {       public:       foo(string s, int i):name(s), id(i){} ; // 初始化列表      private:      string name ;i
C++：3个类的默认成员函数
最新发布
2501_90377063的博客
09-30 862
默认成员函数即是用户没有显式实现，编译器会自动生成的成员函数。⼀个类，我们不写的情况下编译器会默认生成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个。
C++的各种初始化
czw
03-26 7796
原因同样是创建对象时，要初始类成员的每一个成员(如果没有在初始化列表里面，编译器会自动使用它的默认的构造函数进行初始化，但是它没有默认构造函数，所以会编译报错，所以没有默认构造函数的成员变量需要使用初始化列表进行初始化)能用直接初始化和拷贝初始化的地方都能用列表初始化，而且列表初始化能对容器进行方便的初始化，因此在新的C++标准中，推荐使用列表初始化的方式进行初始化。值初始化和默认初始化一样，对于内置类型初始化为0，对于类类型则调用其默认构造函数，如果没有默认构造函数，则不能进行初始化。
C++中类成员初始化方式详细说明
weixin_45805339的博客
12-07 4322
在C++98中，支持了在类声明中使用等号“=”加初始值的方式，来初始化类中静态成员常量。这种声明方式我们也称之为“就地”声明。就地声明在代码编写时非常便利，不过C++98对类中就地声明的要求却非常高。如果静态成员不满足常量性，则不可以就地声明，而且即使常量的静态成员也只能是整型或者枚举型才能就地初始化。而非静态成员变量的初始化则必须在构造函数中进行。 2.构造函数初始化 3.声明时初始化（也称就地初始化，c++11后支持） 在C++98中，支持了在类声明中使用等号“=”加初始值的方式，来初始化类中静态成
C++中的各种初始化方法总结
jonathan_hsu_HW的博客
10-07 2940
1、构造函数 包括有参数和无参数的构造函数，即使不声明无参数的构造函数，编译器默认也会产生一个无参数的构造函数。 在实际使用时，可以采用 TEST t1(1) 的方式显示调用构造函数 和 TEST t2 = 1 的方式隐式调用构造函数，注意这种方式，在构造函数explicit声明后不可用 2、拷贝/复制构造函数 新建1个类对象，并且从另外1个类对象中拷贝内容到新建的对象中， 实际使用时，可以采用 TEST t4(t2) 的方式显示调用构造函数 和 TEST t3 = t2 的方式隐式调用拷贝构造函数，拷贝
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值