24 - 经典问题分析二（析构 & const 对象 & 类成员）

---- 整理自狄泰软件唐佐林老师课程

1. 关于析构的疑问

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

1.1 单个对象创建时构造函数的调用顺序

1- 调用父类的构造过程（后续讲解）
2- 调用成员变量的构造函数（调用顺序和声明顺序相同）
3- 调用类自身的构造函数

• 析构函数与对应构造函数的调用顺序 相反

1.2 多个对象析构时

• 析构顺序和构造顺序相反

1.3 实例分析：构造与析构顺序

#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;
	
    return 0;
}

1.4 关于析构的答案

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

2. 关于 const 对象的疑问

• const 关键字能否修饰类的对象？如果可以，有什么特性？
• const 关键字能够修饰对象
• const 修饰的对象为 只读对象
• 只读对象的 成员变量不允许被改变
• 只读对象是 编译阶段 的概念，运行时无效

2.1 C++ 中的 const 成员函数

• const 对象 只能 调用 const 的成员函数
• const 成员函数中 只能 调用 const 成员函数
• const 成员函数中 不能直接改写 成员变量的值

2.2 const 成员函数的定义

Type ClassName::function(Type p) const

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

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

#include <stdio.h>

class Test
{
	int mi;
public:
	int mk;
	Test(int i);
};

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

int main()
{
    const Test t(1); // 只读对象
	
	t.mk = 10; // 只读对象的成员变量不允许被修改
	
    return 0;
}

#include <stdio.h>

class Test
{
	int mi;
public:
	int mk;
	Test(int i);
	int getMi();
};

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

int Test::getMi()
{
	return mi;
}

int main()
{
    const Test t(1);
	
	printf("t.getMi() = %d\n", t.getMi()); // const 对象只能调用 const 的成员函数
	
    return 0;
}

#include <stdio.h>

class Test
{
	int mi;
public:
	int mk;
	Test(int i);
	int getMi() const; // const 成员函数
};

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

int Test::getMi() const // const 成员函数
{
	return mi;
}

int main()
{
    const Test t(1);
	
	printf("t.getMi() = %d\n", t.getMi()); // const 只读对象可以调用 const 成员函数
	
    return 0;
}

• 如果拷贝构造函数中调用成员函数：

#include <stdio.h>

class Test
{
	int mi;
public:
	int mk;
	Test(int i);
	Test(const Test& t);
	int getMi();
};

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

Test::Test(const Test& t)
{
	mk = t.getMi(); // t 是只读对象
}

int Test::getMi()
{
	return mi;
}

int main()
{
    const Test t(1);
		
    return 0;
}

3. 关于类成员的疑问

• 成员函数和成员变量都是隶属于具体对象的吗？

3.1 从面向对象的角度

• 对象由 属性（成员变量）和 方法（成员函数） 构成

3.2 从程序运行的角度

• 对象由数据和函数构成
  • 数据可以位于栈、堆和全局数据区
  • 函数只能位于代码段

3.3 结论

• 每一个对象都拥有自己独立的属性（成员变量）
• 所有的对象 共享类的方法（成员函数）
• 方法能够直接访问对象的属性
• 方法中的 隐藏参数 this 用于指代 当前对象

3.4 编程实验：成员函数的秘密

#include <stdio.h>

class Test
{
	int mi;
public:
	Test(int i);
	int getMi();
	void print();
};

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

int Test::getMi()
{
	return mi;
}

void Test::print()
{
    printf("this = %p\n", this); // 方法中的隐藏参数 this
								 // 用于指代当前对象
}

int main()
{
	Test t1(1);
    Test t2(2);
    Test t3(3);

    printf("t1.getMi() = %d\n", t1.getMi());
    printf("&t1 = %p\n", &t1);
    t1.print(); // this 指代 t1
    
    printf("t2.getMi() = %d\n", t2.getMi());
    printf("&t2 = %p\n", &t2);
    t2.print(); // this 指代 t2
    
    printf("t3.getMi() = %d\n", t3.getMi());
    printf("&t3 = %p\n", &t3);
    t3.print(); // this 指代 t3
	
    return 0;
}

#include <stdio.h>

class Test
{
	int mi;
public:
	Test(int i);
	Test(const Test& t);
	int getMi();
	void print();
};

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

Test::Test(const Test& t)
{
	printf("Test::Test(const Test& t)      = %p\n", &t); // 传入的是 t1
	mi = t.mi;
	printf("Test::Test(const Test& t) this = %p\r\n", this); // 实际 this 指代 t2
}

int Test::getMi()
{
	return mi;
}

void Test::print()
{
    printf("this = %p\n", this); // 方法中的隐藏参数 this
								 // 用于指代当前对象
}

int main()
{
	Test t1(1);
    Test t2(t1); // 拷贝构造函数中传进去的是对象 t1，实际当前对象 this 指代的是 t2

    printf("t1.getMi() = %d\n", t1.getMi());
    printf("&t1 = %p\n", &t1);
    t1.print();
    
    printf("t2.getMi() = %d\n", t2.getMi());
    printf("&t2 = %p\n", &t2);
    t2.print();
	
    return 0;
}

• 注解：Test t2(t1)；构造函数中传进去的是对象t1，实际当前对象this指代的是t2。