C/C++编程：确定对象在使用前就已经先被初始化了

Myth丶恋晨 2023-01-19 03:15 12阅读 0赞

> 永远在使用对象之前先将它初始化

对于无任何成员的内置类型，你必须手动完成初始化：

int x = 0;
    const char *text = "A c-stype string";
    
    double d;
    std::cin >> d;  // 以读取input stream的方式完成初始化

对于内置类型之外的任何其他东西，初始化责任落在构造函数上。规则很简单：确保每一个构造函数都将被每一个成语初始化：

*  注意：注意是**初始化**而不是**赋值**

class Entry{
        
    public:
    	// 不推荐的做法
        Entry(int num, const std::string & address, const std::string & name){
        
            m_num = num;   
            m_address = address; // 不是初始化而是赋值
            m_name = name;
        }
    private:
        int m_num;
        std::string m_address;
        std::string m_name;
    };

*  C++规定，**对象的成员变量的初始化动作发生在进入构造函数本体之前**
 *  上例中，m\_name 、m\_address 都不是被初始化，而是被赋值。
 *  初始化发生的时间更早，发生于**这些成员的默认构造函数**被自动化调用之时（比进入Entry构造函数本体的时间更早）。除m\_num之外，因为m\_num是**内置类型，不保证一定在你所看到的那个赋值动作的时间点获得初值**

推荐使用成员初始化了列表替代上面的赋值操作：

class Entry{
        
    public:
    	// 推荐
        Entry(int num, const std::string & address, const std::string & name)
            : m_num(num),
              m_address(address),
              m_name(name){
        
            }
    private:
        int m_num;
        std::string m_address;
        std::string m_name;
    };

这个版本效率更高。第一个版本实现调用成员的默认构造函数为m\_name，m\_address设置初值，然后立即再对它们赋新值。第二个版本避免了这个问题，因为初值列中针对各个成员变量而设的实参，被拿去作为各成员变量的构造函数的实参(拷贝构造)

对于大多数类型而言，比起先调用(成员的)默认构造函数然后再调用(成员的)拷贝构造函数，单只调用一次(成员的)拷贝构造函数更搞笑。对于内置类型对象比如m\_num，其初始化和赋值的成本相同，但是为了一致性最好也通过成员初值列表来初始化。同样的，如果你想要默认构造一个成员变量，也推荐使用成员初始化列表，只要指定nothing作为初始化实参即可：

Entry()
            : m_num(0),   // 记得将m_num显示初始化为0
              m_address(), // 调用m_address的默认构造函数
              m_name(){
        
            }

有些情况下即使面对的成员变量属于内置类型（那么其初始化与赋值的成本相同），也一定要使用初值列—如果成员变量是const或者references，它们就一定需要初值，不能被赋值。为避免记住成员变量什么时候必须在成员列表中初始化，什么时候不需要，最简单的做法是：总是使用成员初始化列表

许多类中共有多个构造函数，每个构造函数都有自己的成员初始化列表。多个成员初始化列表的存在就会导致不受欢迎的重复和无聊的工作，这时候可以使用**委托构造函数**

C++有着十分固定的**成员初始化次序**：

*  基类更早于派生类被初始化
 *  类的成员变量总是以声明次序被初始化

一旦你已经很小心的将**内置型成员变量**明确的初始化了，而且也确保你的构造函数运用**成员初始化列表**初始化基类和成员变量，那就只剩下一件事： 不同编译单元中定义的`no-local static`对象的初始化次序：

*  所谓static对象：
    
     *  其寿命从被构造出来直到程序结束为止，因此stack和heap-base对象都被排除。
     *  这种对象包括全局对象、定义于命名空间作用域内的对象、在类内、在函数内、在file作用域内被声明为static的对象
     *  函数内的静态对象被称为`local static`对象(因为它们对函数而言是local)，其他的静态对象被称为`no-local static`对象。
     *  程序结束时static对象会被自动销毁，也就是它们的析构函数会在main()结束时自动调用
 *  所谓编译单元：
    
     *  指产生单一模板文件的那些源码
     *  基本上它是单一源码文件加上其所含有(\#include)的头文件

现在的问题是：如果某个编译单元内的每个non-local static对象的初始化动作使用了另一个编译单元内的每个non-local static对象，它所用到的这个对象可能尚未被初始化，因为C++对**定义于不同编译单元内的non-local static对象的初始化次序无定义**

为什么C++对定义于不同编译单元内的non-local static对象的初始化次序无定义？ 原因：决定它们的初始化次序相当困难，非常困难，甚至无解。最常见的形式，也就是多个编译单元内的non-local static对象经由**模版隐式具现化**(implicit template instantiations)形成，不但不可能决定正确的初始化次序，甚至往往不值得寻找可决定正确次序的特殊情况。

那怎么解决呢？

*  将每个non-local static对象搬到自己的专属函数内（该对象在此函数内被声明为static）。
 *  这些函数返回一个**引用**指向它所含对象。
 *  然后用户调用这些函数，而不直接涉及这些对象

换句话说，non-local static对象被local static对象替换了。这是单例模式的一个常见实现手法。

这是手法的基础在于：

*  C++保证，函数内的local static对象会在**该函数被调用期间**、**首先遇到该对象的定义**时被初始化
 *  所以如果你以**函数调用**(返回一个引用指向local static对象)替换**直接访问non-local static对象**

class FileSystem{
        
    public:
        std::size_t  numDisk() const ;
    };
    FileSystem& tfs(){
        
        static FileSystem fs;
        return fs;
    }
    
    class Directory{
        
    public:
        Directory(){
        
            std::size_t  disks = tfs().numDisk();
        }
    };
    
    
    Directory& tempDir(){
        
        static Directory td;
        return td;
    }

综上：为了避免在对象初始化之前过早的使用它们，你需要做三件事。

*  第一，手动初始化内置型内成员对象
 *  第二，使用成员初始化列表初始化对象中的所有成员
 *  第三，在**初始化次序不确定型**(这主要针对不同编译单元定义的non-local static对象)加强你的设计

# 总结 #

*  为内置对象型进行手动初始化，因为C++不保证初始化它们
 *  构造函数最好使用成员初始化列表，而不要在构造函数本体中使用赋值操作。初始化列表中列出的成员变量，其排列系列应该和它们在类中的声明次序相同
 *  为避免**跨编译单元的初始化次序**问题，请以local static对象替换non-local static对象