C++类中成员变量的初始化

最新推荐文章于 2025-02-01 00:32:41 发布
转载 最新推荐文章于 2025-02-01 00:32:41 发布 · 1.1k 阅读 · 1
文章标签：

#类成员初始化

本文详细对比了C++类中成员变量初始化的两种方式：构造函数初始化列表和构造函数体内赋值，包括初始化顺序、适用场景及效率差异。


C++类中成员变量的初始化有两种方式：

         构造函数初始化列表和构造函数体内赋值。下面看看两种方式有何不同。

         成员变量初始化的顺序是按照在那种定义的顺序。

1 内部数据类型（char，int……指针等）

复制代码
class Animal
{
public:
    Animal(int weight,int height):       //A初始化列表
      m_weight(weight),
      m_height(height)
    {
    }
    Animal(int weight,int height)       //B函数体内初始化
    {
        m_weight = weight;
        m_height = height;
    }
private:
    int m_weight;
    int m_height;
};
复制代码

对于这些内部类型来说，基本上是没有区别的，效率上也不存在多大差异。

当然A和B方式不能共存的。


 

2 无默认构造函数的继承关系中

复制代码
class Animal
{
public:
    Animal(int weight,int height):        //没有提供无参的构造函数 
      m_weight(weight),
      m_height(height)
    {
}
private:
    int m_weight;
    int m_height;
};

class Dog: public Animal
{
public:
    Dog(int weight,int height,int type)   //error 构造函数 父类Animal无合适构造函数
    {
    }
private:
    int m_type;
};
复制代码


这种必须在派生类中构造函数中初始化提供父类的初始化，因为对象构造的顺序是：

 

父类——子类——……

 

所以必须：

 

复制代码
class Dog: public Animal
{
public:
    Dog(int weight,int height,int type):
        Animal(weight,height)         //必须使用初始化列表增加对父类的初始化
    {
        ;
    }
private:
    int m_type;
};
复制代码


 

3 类中const常量，必须在初始化列表中初始，不能使用赋值的方式初始化

 

复制代码
class Dog: public Animal
{
public:
    Dog(int weight,int height,int type):
        Animal(weight,height), 
        LEGS(4)                //必须在初始化列表中初始化
    {
        //LEGS = 4;           //error
    }
private:
    int m_type;
    const int LEGS;
};
复制代码


4 包含有自定义数据类型（类）对象的成员初始化        

 

复制代码
class Food
{
public:
    Food(int type = 10)
    {
        m_type = 10;
    }
    Food(Food &other)                 //拷贝构造函数
    {
        m_type = other.m_type;
    }
    Food & operator =(Food &other)      //重载赋值=函数
    {
        m_type = other.m_type;
        return *this;
    }
private:
    int m_type;
};

（1）构造函数赋值方式 初始化成员对象m_food
class Dog: public Animal
{
public:
    Dog(Food &food)
      //:m_food(food)  
    {
        m_food = food;               //初始化 成员对象
    }
private:
    Food m_food;
};
//使用
Food fd;
Dog dog(fd);   //
Dog dog(fd);结果：
先执行了   对象类型构造函数Food(int type = 10)——> 
然后在执行 对象类型构造函数Food & operator =(Food &other)
想象是为什么？



（2）构造函数初始化列表方式
class Dog: public Animal
{
public:
    Dog(Food &food)
      :m_food(food)                  //初始化 成员对象
    {
        //m_food = food;               
    }
private:
    Food m_food;
};
//使用
Food fd;
Dog dog(fd);   //
Dog dog(fd);结果：执行Food(Food &other)拷贝构造函数完成初始化
复制代码


不同的初始化方式得到不同的结果：

　　　　　　明显构造函数初始化列表的方式得到更高的效率。

C++类中成员变量的初始化有两种方式：

         构造函数初始化列表和构造函数体内赋值。下面看看两种方式有何不同。

         成员变量初始化的顺序是按照在那种定义的顺序。

1 内部数据类型（char，int……指针等）

复制代码
class Animal
{
public:
    Animal(int weight,int height):       //A初始化列表
      m_weight(weight),
      m_height(height)
    {
    }
    Animal(int weight,int height)       //B函数体内初始化
    {
        m_weight = weight;
        m_height = height;
    }
private:
    int m_weight;
    int m_height;
};
复制代码

对于这些内部类型来说，基本上是没有区别的，效率上也不存在多大差异。

当然A和B方式不能共存的。


 

2 无默认构造函数的继承关系中

复制代码
class Animal
{
public:
    Animal(int weight,int height):        //没有提供无参的构造函数 
      m_weight(weight),
      m_height(height)
    {
}
private:
    int m_weight;
    int m_height;
};

class Dog: public Animal
{
public:
    Dog(int weight,int height,int type)   //error 构造函数 父类Animal无合适构造函数
    {
    }
private:
    int m_type;
};
复制代码


这种必须在派生类中构造函数中初始化提供父类的初始化，因为对象构造的顺序是：

 

父类——子类——……

 

所以必须：

 

复制代码
class Dog: public Animal
{
public:
    Dog(int weight,int height,int type):
        Animal(weight,height)         //必须使用初始化列表增加对父类的初始化
    {
        ;
    }
private:
    int m_type;
};
复制代码


 

3 类中const常量，必须在初始化列表中初始，不能使用赋值的方式初始化

 

复制代码
class Dog: public Animal
{
public:
    Dog(int weight,int height,int type):
        Animal(weight,height), 
        LEGS(4)                //必须在初始化列表中初始化
    {
        //LEGS = 4;           //error
    }
private:
    int m_type;
    const int LEGS;
};
复制代码


4 包含有自定义数据类型（类）对象的成员初始化        

 

复制代码
class Food
{
public:
    Food(int type = 10)
    {
        m_type = 10;
    }
    Food(Food &other)                 //拷贝构造函数
    {
        m_type = other.m_type;
    }
    Food & operator =(Food &other)      //重载赋值=函数
    {
        m_type = other.m_type;
        return *this;
    }
private:
    int m_type;
};

（1）构造函数赋值方式 初始化成员对象m_food
class Dog: public Animal
{
public:
    Dog(Food &food)
      //:m_food(food)  
    {
        m_food = food;               //初始化 成员对象
    }
private:
    Food m_food;
};
//使用
Food fd;
Dog dog(fd);   //
Dog dog(fd);结果：
先执行了   对象类型构造函数Food(int type = 10)——> 
然后在执行 对象类型构造函数Food & operator =(Food &other)
想象是为什么？



（2）构造函数初始化列表方式
class Dog: public Animal
{
public:
    Dog(Food &food)
      :m_food(food)                  //初始化 成员对象
    {
        //m_food = food;               
    }
private:
    Food m_food;
};
//使用
Food fd;
Dog dog(fd);   //
Dog dog(fd);结果：执行Food(Food &other)拷贝构造函数完成初始化
复制代码


不同的初始化方式得到不同的结果：

　　　　　　明显构造函数初始化列表的方式得到更高的效率。

c++ 类的成员变量初始化
白熊的窝
01-19 904
最近在做一个关于boost的项目， 修改将原本的多个commandline进行合并精简，合并成一个path路径， 然后再加上不同的hardcode的文件名组成一个完整的路径。由于在使用ptree时会调用静态方法创建一个instance的类， 因此这里需要使用静态成员变量。大概整理了一下以前没有注意过的类的成员变量的初始化。 ###普通成员变量 普通成员变量的初始化可以在构造函数中进行赋值， 也可以...
[C++深入] --- 类成员初始化的三种方式
M2嵌入式
06-27 1016
初始化列表是在构造函数冒号后对成员进行初始化，这是在成员被分配内存的同时进行的初始化操作。这样避免了成员变量先被默认构造然后再赋值的过程。
C++中类成员变量初始化总结
01-21
1、普通的变量： 　　一般不考虑啥效率的情况下 可以在构造函数中进行赋值。考虑一下效率的可以再构造函数的初始化列表中进行。 　　class CA 　　{ 　　public: 　　int data; 　　…… 　　public: 　　CA(); 　　…… 　　}; 　　CA::CA():data(0)//……#1……初始化列表方式 　　{ 　　//data = 0;//……#1……赋值方式 　　}; 　　2、static 静态变量： 　　static变量属于类所有，而不属于类的对象，因此不管类被实例化了多少个对象，该变量都只有一个。在这种性质上理解，有点类似于全局
C++成员变量的初始化顺序问题
热门推荐
zhaojinjia的专栏
04-11 2万+
问题来源： 由于面试题中，考官出了一道简单的程序输出结果值的题：如下， class A { private: int n1; int n2; public: A():n2(0),n1(n2+2){} void Print(){ cout << "n1:" << n1 << ", n2: " << n2 <<endl; } }; int main() { A a
C++语言中类的成员变量初始化
Second的专栏
03-11 6597
C++语言中类的成员变量初始化 C++中对类的成员变量进行初始化的方法通常有如下两种： 1.构造函数进行初始化 例如： class MyClass{ public: MyClass(int nValue) { var = nValue; } private: int var; } 2.在构造函数的初始化列表中进行初始化（成员初始化列表） class MyClass{
C++类的静态成员初始化详细讲解
09-05
整型和枚举型const静态成员可以直接在类声明中初始化，而其他类型的静态成员则需要在类声明之外初始化，并使用作用域解析运算符指定所属的类。注意静态成员的初始化只应在一个地方完成，避免在头文件中，以防止重复...
C++类成员变量初始化的顺序是什么
Warren++的博客
05-22 1052
C++类成员变量初始化的顺序是什么
C++全局变量初始化的一点总结
12-22
C++中的全局变量初始化是一个重要的话题，涉及到程序的正确性和可预测性。全局变量，即具有静态存储期的变量，其生命周期始于程序开始，终于程序结束。本文将深入探讨全局变量初始化的时机、方式以及一些处理特殊...
关于C++类的成员初始化列表的相关问题
09-02
C++类的成员初始化列表是构造函数中一种特殊的形式，用于在对象实例化时直接对类的成员变量进行初始化。...在编写涉及构造函数和成员变量初始化的代码时，应优先考虑使用初始化列表，以确保程序的性能和正确性。
C++语言类成员变量初始化总结
weixin_33918357的博客
12-11 302
共有5种方法。 第1种,在无参数的构造函数中初始化; 第2种，带参数的构造函数中初始化； 第3种,直接给成员变量赋值; 第4种,调用成员函数来初始化成员变量; 第5种，用this指针； 分别叙述。 方法一： classanimal{public:inta,b;animal();};animal::animal(){...
【C++】类内成员变量的初始化
m0_57168310的博客
09-07 5403
C++11中，非静态常量、非静态变量、静态常量---可以在类内初始化。用=（）或{}都可以。静态变量 ---不可以在类内初始化。非静态常量（const int）必须初始化。初始化列表可以对非静态常量和变量初始化。
C++类的成员变量初始化
张芬奇的博客
09-27 838
构造函数初始化：成员变量的构造函数初始化是在类的构造函数中为成员变量提供初始值。声明初始化：成员变量的声明初始化是在类的声明中为成员变量提供默认值。这样，无论通过哪个构造函数创建对象，成员变量都会使用相同的默认值。在实际使用中，如果成员变量的初始值是固定的，且不会根据不同的构造函数参数而改变，可以使用声明初始化。在C++中，类的成员变量可以在声明时进行初始化，也可以在构造函数中进行初始化。如果成员变量的初始值需要根据不同的构造函数参数而改变，可以使用构造函数初始化。
C++类中成员变量初始化
shixiaoguo90的专栏
05-06 2030
C++类中成员变量包括主要四种： 普通成员变量，常量成员变量，静态成员变量，静态常量成员变量 上述成员变量该如何初始化，注意不是赋值。 由于普通成员变量和常量成员变量，每一个类实例化，都一份内存拷贝。C++规定成员变量在声明（注意声明与定义区别）时，不允许初始化，因此这些变量只能放在构造函数初始化列表中。 静态成员变量所有类实例化，只有一份内存拷贝，不能放在构造函数中初始化， 因为共享
c++类成员变量初始化详解
bitcarmanlee的博客
04-16 2万+
1.类初始化顺序 当类初始化的时候，会调用其构造函数并进行初始化。当对象结束其生命周期，会调用析构函数进行资源回收。 注意类在调用资深构造函数之前，首先会调用其成员变量构造函数并进行初始化，再进入自身构造函数进行初始化。成员变量的声明顺序，就是初始化顺序。后面我们提到的很多情况就跟这个有关系，后面再进行详细解读。 2.声明时初始化 第一种方式是在成员变量声明时初始化。可以看如下示例。 class D { int a = 10; }; 在声明变量a的时候即给其初始化为10。不过注意这种写法是c++1
C++类成员变量是如何初始化的
weixin_45075170的博客
02-01 1936
初始化方式适用场景示例默认初始化未显式初始化时int x;构造函数初始化列表推荐方式，高效且必须用于const和引用成员构造函数体内赋值不推荐，效率较低y = 20;就地初始化C++11 引入，简洁直观int x = 10;静态成员变量初始化静态成员变量（类外定义）
C++类中成员变量的初始化的两种方式
顺其自然~专栏
03-16 4940
​​​​​​C++类中成员变量的初始化有两种方式： 构造函数初始化列表 构造函数体内赋值 下面看看两种方式有何不同。 成员变量初始化的顺序是按照在那种定义的顺序。 1、内部数据类型（char，int……指针等） class Animal { public: Animal(int weight,int height): //A初始化列表 m_weight(weight), m_height(height) {
C++ 类成员变量初始化
zhangyikuaile的博客
04-18 219
参考：https://blog.youkuaiyun.com/sinat_20265495/article/details/53642761 补充：变量初始化顺序，不论是在初始化列表，还是构造函数内部，必须和声明顺序一致，否则数据为乱值。 class CExample { public: int a; float b; //构造函数初始化列表 CExample(): a(...
c++类成员变量的初始化
qq_27390023的博客
04-02 419
在C++中，类是一种用户自定义的数据类型，用于封装数据和方法。类包含成员变量和成员函数，其中成员变量用于表示类的状态或数据，而成员函数用于操作这些数据或执行特定的行为。构造函数的作用是初始化对象的状态，确保对象在创建后处于一个合适的状态。它可以执行各种初始化操作，如初始化成员变量、分配内存等。构造函数是一种特殊类型的成员函数，用于在对象创建时对对象进行初始化。构造函数的名称与类名相同，并且没有返回类型（包括。在创建对象时，构造函数会自动调用。
c++类中成员变量初始化顺序是按声明顺序初始化还是按初始化列表顺序初始化，顺序是什么样的
最新发布
06-05
<think>我们已知C++类成员变量初始化顺序的相关知识。现在，我需要根据用户的问题，系统地讲解C++类成员变量初始化顺序的规则。同时，按照系统指令，我需要使用正确的LaTeX格式和中文回答，并在最后生成相关问题。用户的问题是：“我想了解C++类中成员变量的初始化顺序规则请问C++类成员变量初始化顺序声明顺序初始化列表顺序”根据引用内容，我们可以总结如下：1.初始化顺序首先遵循继承关系：先初始化基类，然后初始化派生类的成员变量。2.派生类中成员变量的初始化顺序不是由初始化列表中的顺序决定的，而是由成员变量在类定义中的声明顺序决定的。3.如果成员变量在初始化列表中的顺序与声明顺序不一致，可能会导致一些成员变量在初始化时使用了尚未初始化的其他成员变量，从而产生未定义行为（如引用[3]中的例子）。4.对于常量成员（const）和引用成员（&），它们必须在初始化列表中进行初始化，因为无法在构造函数体内进行赋值。5.初始化列表的初始化操作发生在构造函数体执行之前。另外，引用[1]指出：“首先是基类，然后是成员变量按照它们在类中声明的顺序进行初始化。初始化列表中的顺序不影响实际的初始化顺序。”引用[2]和[3]也强调了声明顺序的重要性。因此，回答可以这样组织：一、整体初始化顺序：1.基类的初始化（如果有基类，按照继承列表的顺序）2.派生类成员变量的初始化（按照在类定义中的声明顺序）二、成员变量初始化细节：-每个成员变量的初始化是在初始化列表中指定的，如果没有在初始化列表中指定，则：-如果成员是类类型且具有默认构造函数，则调用默认构造函数进行初始化。-内置类型（如int、指针等）如果没有初始化，则其值是未定义的。-初始化列表中只能指定普通成员变量的值，但不能改变初始化的顺序。三、初始化列表顺序与声明顺序的关系：-初始化列表的顺序不影响实际初始化顺序，实际顺序只取决于声明顺序。-如果在初始化列表中使用一个成员变量去初始化另一个成员变量，而声明顺序在后的变量被用来初始化声明顺序在前的变量，则会导致未定义行为（因为被使用的那个变量还没有初始化）。四、必须使用初始化列表的情况：1.常量成员（const）2.引用成员（&）3.没有默认构造函数的类成员五、举例说明（如引用[3]的例子）：在类A中，成员变量声明顺序为a,b,c。构造函数初始化列表写的是b(1),a(b),c(b)。由于初始化顺序是a先于b，所以初始化a时，b还没有被初始化，因此a的值是未定义的（乱码）。接下来，我们按照要求进行回答：</think> ### C++类成员变量初始化顺序规则 在C++中，类成员变量的初始化顺序遵循以下严格规则： #### 1. **整体初始化顺序** - **基类优先原则**：如果有继承关系，先初始化所有**直接基类**（按照继承声明顺序） - **成员变量顺序**：随后初始化**当前类的成员变量** ```cpp class Base {}; class Derived : public Base { // 1. 先初始化Base int a; // 2. 按照声明顺序初始化成员 int b; }; ``` #### 2. **成员变量初始化细节（核心规则）** [^1][^2][^3] - **声明顺序决定初始化顺序**： - 成员变量的初始化顺序**严格按类定义中的声明顺序**进行 - 初始化列表中的顺序**不改变**实际初始化顺序 - *代码示例*： ```cpp class Test { public: Test() : y(5), x(y) {} // ⚠️ 危险：x在y前初始化 private: int x; // 先声明x int y; // 后声明y }; ``` ➔ `x(y)`会使用未初始化的`y`，导致未定义行为（UB） - **必须用初始化列表的情况**： - 常量成员（`const`） - 引用成员（`&`） - 无默认构造函数的类成员 ```cpp class MustInitList { public: MustInitList(int val) : ref(val), cval(10) {} // ✅ 必须初始化列表 private: const int cval; // const成员 int& ref; // 引用成员 }; ``` #### 3. **初始化列表 vs 构造函数赋值** | 特性 | 初始化列表 | 构造函数体内赋值 | |--------------------|-------------------------------|------------------------| | **执行时机** | 进入构造函数体**前** | 进入构造函数体**后** | | **效率** | 直接构造（更高效率） | 先默认构造再赋值 | | **特殊成员支持** | 支持const/引用/无默认构造成员 | 不支持这些成员 | | **顺序依赖** | 仍受声明顺序制约 | 无顺序依赖 | #### 4. **关键陷阱与示例** ```cpp class Danger { public: Danger() : b(1), a(b) {} // 初始化列表顺序≠实际顺序 int a; int b; }; ``` - **实际初始化顺序**：`a(b)` → `b(1)`（因声明顺序是`a`先于`b`） - **结果**：`a`用未初始化的`b`赋值 → 输出`a=乱码, b=1` [^3] - **修复方案**：调整声明顺序或避免交叉初始化 #### 5. **总结规则** 1. 基类成员优先于派生类初始化 2. 成员变量初始化**只认声明顺序** 3. 初始化列表顺序可读但不改变实际顺序 4. const/引用/无默认构造成员**必须**用初始化列表 5. 避免在初始化列表中使用其他未初始化的成员
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值