C++对象的初始化

最新推荐文章于 2024-09-01 08:30:00 发布
最新推荐文章于 2024-09-01 08:30:00 发布
阅读量940 收藏
点赞数
分类专栏： C++语言 文章标签： C++ 初始化 构造函数列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sanoseiichirou/article/details/50120249
版权

参考：《Effective C++》
《Effective C++》条款4学习笔记

1. 综述

C++对于对象的初始化大致分为两块：内置类型和非内置类型+局部和全局。

1.1 内置类型和非内置类型

  • 内置类型指的是类似int，short，char，double，float，long，long long等来自C语言的部分。C++对于内置类型是没有初始化的，也就是他的值是随机的。
#include <iostream>

int main(){
    int a;
    short b;
    char c;
    double d;
    std::cout<<a<<std::endl;
    std::cout<<b<<std::endl;
    std::cout<<c<<std::endl;
    std::cout<<d<<std::endl;
    return 0;
}

运行结果：

这里写图片描述

  • 非内置类型：用户自定义的类型（class、struct），STL的模板类等。它们一般通过构造函数初始化。
#include <iostream>
#include <vector>

class demo{
public:
    demo():dat(0){}
    demo(int dat):dat(dat){}
    int & get(){return dat;}
private:
    int dat;
};

int main(){
    //用户自定义的类型
    demo a;
    std::cout<<a.get()<<std::endl;
    //STL
    std::vector<int>myvector;//vector此时被初始化为空
    std::cout<<std::boolalpha<<myvector.empty()<<std::endl;
    return 0;
}

运行结果：

0
true

1.2 局部和全局

  • C++继承了C：会自动初始化全局变量，一般用0填充（自定义类型和其他类型通过构造函数初始化）
  • 但是对于内置类型的局部变量，C++和C一样，不会初始化，而是随机值
#include <iostream>

int DATA;//定义一个内置类型的全局变量

int main(){
    int data;
    std::cout<<DATA<<std::endl;//打印全局的DATA
    std::cout<<data<<std::endl;//打印局部变量的data
    return 0;
}

运行结果：

0
4291726

全局变量中的DATA被默认初始化为0，但是局部变量data确实一个随机值。

1.3 小结

所以对于内置类型的局部变量我们只能手动初始化了。

2 非内置类型的初始化

我们都明白，非内置类型的初始化的重任当落在构造函数(Constructor)身上。

2.1 构造函数的两种写法

  • 第一种
#include <iostream>
#include <string>

typedef enum{
    male,female
}gender;

class person_base{
public:
    //默认构造函数
    person_base(){
        std::cout<<"person_base default constructor called"<<std::endl;
        m_age=0;
        m_name=std::string();
        m_gender=gender::male;
        m_nationality=std::string();
    }
    //构造函数
    person_base(const unsigned int & age,const std::string & name,const gender & gen,const std::string & nationality){
        std::cout<<"person_base unique constructor calld"<<std::endl;
        m_age=age;
        m_name=name;
        m_gender=gen;
        m_nationality=nationality;
    }
    ~person_base(){}
private:
    unsigned int m_age;//年龄
    std::string m_name;//姓名
    gender m_gender;//性别
    std::string m_nationality;//国籍
};
  • 第二种
class person_base{
public:
    //默认构造函数
    person_base():m_age(0),m_name(),m_gender(male),m_nationality("unknown"){
        std::cout<<"person_base default constructor called"<<std::endl;
    }
    //构造函数
    person_base(const unsigned int & age,const std::string & name,const gender & gen,const std::string & nationality)
                :m_age(age),m_name(name),m_gender(gen),m_nationality(nationality){
        std::cout<<"person_base unique constructor calld"<<std::endl;
    }
    ~person_base(){}
private:
    unsigned int m_age;//年龄
    std::string m_name;//姓名
    gender m_gender;//性别
    std::string m_nationality;//国籍
};
  • 以上两种初始化的效果是一样的，但是二者的效率不同。前者的效率较低，后者（使用初始化列表）的效率较高。

我们使用更加简单的类说明二者的效率差。

注意将焦点放在myclass类上。

#include <iostream>
#include <string>

class demo {
public:
    demo() :dat(0) {
        std::cout << "demo default constructor" << std::endl;
    }
    demo(int d) :dat(d) {
        std::cout << "demo unary constructor" << std::endl;
    }
    demo(const demo & other) :dat(other.dat) {
        std::cout << "demo copy constructor" << std::endl;
    }
    const demo& operator=(const int & dat) {
        this->dat = dat;
        std::cout << "demo assign operator" << std::endl;
        return *this;
    }
    int getdata() { return dat; }
    const int getdata()const { return dat; }
private:
    int dat;
};

class myclass {
public:
    myclass() {
        std::cout << "myclass default constructor" << std::endl;
        m_int = 0;
        m_double = 0;
        m_demo = 0;
    }
    myclass(const int &dat, const double &db, const int& demo_dat) {
        std::cout << "myclass unique constructor" << std::endl;
        m_int = dat;
        m_double = db;
        m_demo = demo_dat;
    }
private:
    int m_int;
    double m_double;
    demo m_demo;
    //friend member
    friend std::ostream & operator<<(std::ostream & out, const myclass & other);
};
std::ostream & operator<<(std::ostream & out, const myclass & other) {
    return out << "m_int=" << other.m_int << "\nm_double="
        << other.m_double << "\nm_demo data=" << other.m_demo.getdata();
}

int main() {
    myclass obj(1, 2.2, 3);
    std::cout << obj << std::endl;
    std::cin.get();
    return 0;
}

运行结果：

demo default constructor
myclass unique constructor
demo assign operator
m_int=1
m_double=2.2
m_demo data=3

按照我们的预测，我们调用的构造函数应该只有1个。

当我们调用了myclass的构造函数，打印：myclass unique constructor

我们预测的结果应该是，下面这样：
myclass unique constructor <-调用了myclass的构造函数
demo unary constructor <-此时为初始化，调用的应该是构造函数
m_int=1
m_double=2.2
m_demo data=3

但是，我们发现运行结果和我们的猜想大相径庭。

这是怎么回事呢？
答：“C++规定，对象的成员变量的初始化动作发生在进入构造函数本体之前。”——《Effective C++》

  • 所以，在进入myclass的构造函数体初始化demo之前，demo已经调用了默认的构造函数初始化了
  • 随后的初始化中，我们又在函数体中调用=赋值操作，这就造成了不必要的重复调用。这就是为什么第一种构造函数的写法不被推荐的理由。
  • 对于内置类型的int和double不受这种规则的影响 ( 因为C++本来就不会初始化它们，编译器只是直接划了一块内存给它们。它们的值就是内存中原来那些垃圾二进制。所以，对于内置类型，两种构造函数的写法的效率是相当的 ) 。
  • 使用初始化列表则不会发生上述的情况。（这也是我们为什么需要在初始化列表中才能初始化类中的引用或是const变量）
  • 所以，第二种（使用初始化列表）的构造函数的写法效率会高于前者。
  • 所以，我们一般会在初始化列表中，将类中所有的变量都列出来，这样就可以保证变量不会被遗漏了
  • 对于内置类型，我们建议同样列在初始化列表中，因为这样可以使初始化看起来整齐一致，程序员也就没有必要记忆和判断：何种变量必需在初始化列表中初始化而何种没有必要那么做。
  • 当然有时也会遇到初始化列表特别长的情况。此时我们可以将“赋值表现的和初始化一样好”的变量，放在一个私有的函数，供构造函数调用。下面是例子：
class test{
public:
    test():dat(0){}
    test(int data):dat(data){}
private:
    int dat;
};

class myclass:public test{
public:
    myclass(const int &data,const char &ch,const double& db,int data_test):test(data_test){
        init(data,ch,db);
    }
private:
    //将内置类型的初始化些写成函数，供构造函调用
    void init(const int &data,const char &ch,const double &db){
        m_int=data;
        m_char=ch;
        m_double=db;
    }
    int m_int;
    char m_char;
    double m_double;
    test m_t;
};

所以，我们将上面的代码修改优化后就是下面这一段：

#include <iostream>
#include <string>

class demo {
public:
    demo() :dat(0) {
        std::cout << "demo default constructor" << std::endl;
    }
    demo(int d) :dat(d) {
        std::cout << "demo unary constructor" << std::endl;
    }
    demo(const demo & other) :dat(other.dat) {
        std::cout << "demo copy constructor" << std::endl;
    }
    const demo& operator=(const int & dat) {
        this->dat = dat;
        std::cout << "demo assign operator" << std::endl;
        return *this;
    }
    int getdata() { return dat; }
    const int getdata()const { return dat; }
private:
    int dat;
};

class myclass {
public:
    myclass() :m_int(0), m_double(0), m_demo(0) {
        std::cout << "myclass default constructor" << std::endl;
    }
    myclass(const int &dat, const double &db, const int& demo_dat)
        :m_int(dat), m_double(db), m_demo(demo_dat) {
        std::cout << "myclass unique constructor" << std::endl;
    }
private:
    int m_int;
    double m_double;
    demo m_demo;
    //friend member
    friend std::ostream & operator<<(std::ostream & out, const myclass & other);
};
std::ostream & operator<<(std::ostream & out, const myclass & other) {
    return out << "m_int=" << other.m_int << "\nm_double="
        << other.m_double << "\nm_demo data=" << other.m_demo.getdata();
}

int main() {
    myclass obj(1, 2.2, 3);
    std::cout << obj << std::endl;
    std::cin.get();
    return 0;
}

运行结果：

demo unary constructor
myclass unique constructor
m_int=1
m_double=2.2
m_demo data=3

3. 继承中构造函数的调用顺序

继承中，构造函数的调用总是从基类开始的。
在多继承的情况下，基类构造函数是按照继承列表从左到右的顺序初始化的。

#include <iostream>

class baseA {
public:
    baseA() { std::cout << "baseA constructor" << std::endl; }
};

class baseB {
public:
    baseB() { std::cout << "baseB constructor" << std::endl; }
};

class myclassA :public baseA,public baseB{
public:
    myclassA() { std::cout << "myclassA constructor" << std::endl; }
};

class myclassB :public baseB, public baseA {
public:
    myclassB() { std::cout << "myclassB constructor" << std::endl; }
};

int main() {
    myclassA a;
    std::cout << '\n';
    myclassB b;
    std::cin.get();
    return 0;
}

运行结果：

baseA constructor
baseB constructor
myclassA constructor

baseB constructor
baseA constructor
myclassB constructor

4. 类中成员的初始化顺序

类中成员的初始化顺序是：按照成员声明的顺序来初始化的。
由此，我们得知：初始化列表的顺序并不是成员的初始化顺序。
所以，我们 有时 会受到成员初始化顺序的困扰。

#include <iostream>

class myclass {
public:
    myclass(int dat) :b(dat), a(b) {}
    int a, b;
};

int main() {
    myclass my(100);
    std::cout << "a=" << my.a << std::endl;
    std::cout << "b=" << my.b << std::endl;
    std::cin.get();
    return 0;
}

运行结果：

a=-858993460
b=100

  • 我们可以看到，a此时是一个非常随机的值。
  • 原因就是：因为a比b的声明要早。所以，a的初始化早于b（尽管此时的初始化列表中b写在前），b此时没有初始化，所以会将一个随机值传递给a。
  • 这就是一个陷阱，不注意就会掉进去
  • 所以，我们的做法是：初始化列表中的顺序和声明的顺序保持一致

5. 转载请注明出处

seiiseii
关注
专栏目录
C++ 对象初始化
yly的博客
08-05 4787
在类的声明时可以初始化，但不能使用（）括号方式初始化。 1. 类模板 允许的参数类型 2. 类构造函数初始化顺序 3.
C++对象初始化
扬风踏浪
07-27 2万+
在C++里，对象初始化是一个非常重要但又容易令人混淆的问题。这里是自己的一些总结。 一。初始化与赋值的含义：    初始化：包括创建（或说定义）对象并且赋给初值。（如果一个对象只被创建而没有被初始化，则该变量只能用于被赋值）。    赋值： 擦除对象的当前值并用新值代替。二。内置
C++创建并初始化对象
最新发布
weixin_44259499的博客
09-01 2406
在创建对象之前，首先需要定义一个类。类是对象的蓝图，定义了对象的属性和行为。类通常包含成员变量（属性）和成员函数（方法）。在这个示例中，Person类包含两个成员变量name和age，以及一个成员函数display()用于显示对象的信息。对象的创建：可以在栈上或堆上创建对象，通过类的定义实例化对象。对象的初始化：主要通过构造函数完成，包括默认构造函数、带参数的构造函数和使用初始化列表。拷贝构造函数：用于创建对象的副本，在需要复制对象时调用。对象的销毁。
C++ 初始化对象
weixin_45540063的博客
02-25 256
为自用学习c++不懂处的笔记。
C++初始化对象
weixin_42547035的博客
09-09 333
初始化和赋值的区别 在一个构造函数中，ABEntry:ABEntry(const std::string&amp; name,const std::string&amp; address) { theName=name; theAddress=address; } 这个为赋值语句； ABEntry:ABEntry(const std::string&amp; name,const ...
C++对象初始化[文].pdf
10-11
C++对象初始化是编程过程中一个至关重要的概念，它涉及到如何为新创建的对象赋予初始值。在C++中，对象初始化可以分为两类：初始化和赋值，它们之间有着本质的区别。 初始化是在创建对象的同时为其赋予初始值，而...
C++使用初始化列表的方式来初始化字段的方法
08-26
C++语言中，初始化列表是一种常用的初始化对象成员的方法。今天，我们来探讨C++使用初始化列表的方式来初始化字段的方法。 首先，让我们了解什么是初始化列表。初始化列表是C++语言中的一种语法结构，用于在构造...
c++ 子类构造函数初始化及父类构造初始化的使用
08-18
C++ 中的构造函数初始化是指在类对象创建时对其进行初始化的过程。构造函数是类的特殊成员函数，用于初始化类对象。在 C++ 中，子类构造函数的初始化涉及到父类构造函数的调用，否则将无法正确地初始化从父类继承来...
关于C++类的成员初始化列表的相关问题
09-02
C++类的成员初始化列表是构造函数中一种特殊的形式，用于在对象实例化时直接对类的成员变量进行初始化。这种列表在特定情况下是必要的，因为它可以提高代码的效率并确保正确的初始化顺序。 首先，成员初始化列表在...
【c++】对象初始化
blanklog的博客
04-16 4665
目录 1. 默认初始化 2.零初始化 3.值初始化 4.直接初始化 5.复制初始化 6.聚合初始化 7.列表初始化 C++类型大致分为： 标量: int; float; char; bool; enum; void,nullptr_t; 指针；引用 复合体：数组；union；class/struct 根据生存期大致可分为： 静态：全局，static变量 自动：局部变量，类非静态数据成员 这些类型的初始化行为可以分为以下几种： 1. 默认初始化 语法： T obj; ne
C++ 类对象初始化
鲸落博客
05-01 1352
当创建一个类的实例时，如果没有定义构造函数，系统会自动生成一个无参构造函数，并自动初始化成员变量。内置类型的变量（如int、double、指针等）会被初始化为一个未定义的值，而自定义类型的变量（如类、结构体）会调用默认构造函数进行初始化。
C++对象的初始化和处理
tydo达令的博客
04-26 1650
生活中我们买的电子产品都基本会有出厂设置!在某一天我们不用时候也会删除一些自己信息数据保证安全。C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。
[c++] c++对象的初始化方式
blanklog的博客
09-25 2110
C++的对象初始化主要分为: 默认初始化 值初始化 零初始化 直接初始化 复制初始化 列表初始化 聚合初始化
C++ 对象的初始化和清理
热门推荐
ywl470812087的博客
07-05 11万+
4.2对象的初始化和清理 ●生活中我们买的电子产品都基本会有出厂设置,在某-天我们不用时候也会删除一些自己信息数据保证安全 ●C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。 4.2.1构造函数和析构函数 对象的初始化和清理也是两个非常重要的安全问题 一个对象或者变量没有初始状态，对其使用后果是未知 同样的使用完一个对象或变量， 没有及时清理，也会造成一定的安全问题 C+ +利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动追用，完成对象初始化和清理工作。
C++：对象初始化
glz618的博客
06-28 1097
C++对象初始化总结
C++中的对象初始化
weixin_33893473的博客
02-05 584
　　 当对象在创建时获得了一个特定的值，我们说这个对象被初始化。初始化不是赋值，初始化的含义是创建变量赋予其一个初始值，而赋值的含义是把当前值擦除，而以一个新值来替代。对象初始化可以分为默认初始化、直接初始化、拷贝初始化以及值初始化。   // （1）默认初始化 int i1;//默认初始化，在函数体之外(初始化为0) int f(void) { int i2...
c++对象的初始化，复制和销毁
邵光亮的博客
06-22 1181
对象的初始化： 对象在创建时获得了一个特定的值，我们说这个对象被初始化。初始化不是赋值，初始化的含义是创建变量赋 予其一个初始值，而赋值的含义是把当前值擦除，而以一个新值来替代。 默认初始化： 如果定义变量时没有指定初值，则变量被默认初始化，此时变量被赋予了“默认值” 1、如果是内置类型的变量且未被显示初始化，它的值由位置决定。定义在任何函数体之外的变量被...
C++对象初始化与构造函数
在C++编程中，对象初始化是一个至关重要的概念，特别是在构建复杂的数据结构和类层次时。本课件详细介绍了对象初始化的一些关键点，强调了自定义构造函数的必要性和初始化的位置规则。 首先，对于自定义构造函数的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值