1，当程序中存在多个对象的时候，如何确定这些对象的析构顺序？

 

2，单个对象创建时构造函数的调用顺序（工程经验总结）：

    1，调用父类的构造过程；

    2，调用成员变量的构造函数（调用顺序与声明顺序相同）；

       1，某个类的成员是其它类的对象；

    3，调用类自身的构造函数；

       1，析构函数与对应构造函数的调用顺序相反；

   

3，多个对象析构时：

    1，构造顺序与析构顺序相反；

   

4，构造与析构顺序实例分析：

#include <stdio.h>

class Member
{
    const char* ms;
    
public:
    Member(const char* s)
    {
        printf("Member(const char* s): %s\n", s);
        
        ms = s;
    }
    
    ~Member()
    {
        printf("~Member(): %s\n", ms);
    }
};

class Test
{
    Member mA;
    Member mB;
    
public:
    Test() : mB("mB"), mA("mA")
    {
        printf("Test()\n");
    }
    
    ~Test()
    {
        printf("~Test()\n");
    }
};

Member gA("gA");

int main()
{
    Test t;  // gA
             // mA
             // mB
             // Test()
             // ...
             //~Test()
             // mB
             // mA
             // gA
    
    return 0;
}

   

5，对于栈对象和全局对象，类似于入栈与出栈的顺序，最后构造的对象最先析构；堆对象的析构发生在使用 delete 的时候，与 delete 的顺序相关；

  

6，const 关键字能否修饰类的对象？如果可以，有什么特性？

    1，const 关键字能够修饰对象；

       1，类也是用户自定义的数据类型，类是从 struct 进化而得到的一个全新关键字，struct 专门用来定义结构体，其定义的结构体在 C 语言中依旧是变量，既然是变量，就可以被 cosnt 所修饰；

       2，对应的，对象在某种角度也是变量，所以也可以被 const 修饰；

    2，const 修饰的对象为只读对象；

       1，这是唯一的可能性；

    3，只读对象的成员变量不允许被改变；

       1，对象就是由一系列的成员变量构成的，对象已经是只读的了，也就意味着成员变量是不允许被改变的；

    4，只读对象是编译阶段的概念，运行时无效；

       1，只读对象起始还是可以被改变的；

   

7，C++ 中的 const 成员函数：

    1，const 对象只能调用 const 的员函数；

       1，因为 const 对象的 this 指针是底层常量，不能拷贝给非 const 的成员函数的 this 指针，因为后者的 this 是变量，这会改变 const *this 的属性，造成其指向的对象会被改变；

    2，const 成员函数中只能调用 const 成员函数；

       1，底层 const 指针不能拷贝给非 const 指针；

    3，const 成员函数中不能直接改写成员变量的值；

       1，const 成员函数只能被 const 对象调用，而此时其成员函数也底层 const 的，不能修改底层 const 指针指向的变量；

    4，const 成员函数特殊的意义是被只读对象调用；

       1，底层 const 指针不能拷贝给非 const 指针；

   

8，const 成员函数的定义：

    1，Type ClassName::function(Type p) const

       1，声明之后，函数体之前；

    2，类中的函数声明与实际函数定义中都必须带 const 关键字；

   

9，类的 const 函数初探编程实验：

#include <stdio.h>

class Test
{
    int mi;
public:
    int mj;

    Test(int i);
    Test(const Test& t);
    int getMi() const;
};

Test::Test(int i)
{
    mi = i;
}

Test::Test(const Test& t)
{
    // mi = t.getMi(); getMi() 非常函时，t 是对象的常引用，t 这个对象代表的引用代表只读对象，只能调用 const 函数；
    mi = t.mi;  // 这个时候可以，mi 是私有的，能够通过点操作符来访问吗？不是说只有对象自己的成员函数才可以访问自己的成员变量吗？这就引出了本文10中的问题；
}
    
int Test::getMi() const 
{
    // mi = 2; 这里出错，不能够修饰 mi 的值；
    return mi;
}

int main()
{
    Test t(1);
    
    const Test t1(1);  // 实际工程开发中，并不一定每一个成员函数