23、经典问题解析二以及const 对象

1、关于析构的疑问

当程序中存在多个对象时，我们之前确定了对象的构造顺序：比如局部对象按照程序执行流，堆对象当程序执行流到达 new 语句时创建对象，全局对象的创建顺序是不确定的。
所以，我们如何确实这些对象的析构顺序呢？

• 单个对象创建时构造函数的调用顺序
  1、调用 父类 的构造过程（后续课程讲解）
  2、调用成员变量的构造函数（调用顺序与声明顺序相同）
  3、调用类自身的构造函数

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

• 多个对象析构时
  — 析构顺序与构造顺序相反

#include <stdio.h>
class Member
{
private:
	const char* ms;
public:
	Member(const char* s)
	{
		ms = s;
		printf("Member(const char* s):%s\n",s);
	}
	~Member()
	{
		printf("~Member():%s\n",ms);
	}
};
class Test
{
private:
	Member m1;
	Member m2;
public:
	Test():m2("m2"), m1("m1")
	{
		printf("Test()\n");
	}
	~Test()
	{
		printf("~Test()\n");
	}

};
Member me("me");
int main()
{
	Test t;
	return 0;
}

分析：首先肯定是进行全局对象的构造，调用Member的构造函数。其次Test t 这个类里面的成员变量是另一个类的对象，所以先调用另一个类的对象的构造函数，再调用类自身的构造函数。然后的话析构顺序是与构造顺序相反的。

关于析构的答案

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

2、关于 const 的疑问

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

• const 关键字能够修饰对象
• const 修饰的对象为只读对象
• 只读对象的成员变量不允许被改变
• 只读对象只是编译阶段的概念，运行时无效

C++中的 const 成员函数
— const 对象只能调用 const 成员函数
— const 成员函数中只能调用const 成员函数
— 普通对象也可以调用 const 成员函数
— 普通对象优先调用非const函数，如果没有非const函数，那么就调用const函数
— const 成员函数中不能直接改写成员变量的值，因为 const 对象里面的成员变量都是只读的

#include <iostream>

using namespace std;

class Test
{
private:
	int mi;
public:
	Test()
	{
		mi = 0;
	}
	Test(int i)
	{
		mi = i;
		printf("Test(int i):%d\n", mi);
	}
	Test(const Test& obj)
	{
		mi = obj.mi;
		printf("Test(const Test& obj):%d\n", mi);
	}
	void print()
	{
		cout << "大哥" << endl;
	}
	void print()const
	{
		cout << "大哥牛批" << endl;
	}
};
int main()
{
	Test t;
	t.print();

	return 0;
}

• const 成员函数的定义
  — Type ClassName::function（Type p）const
  — 类中的 函数声明 与实际 函数定义 中都必须 const 关键字

#include <stdio.h>

class Test		//类的声明
{
private:
	int mi;
public:
	Test(int i);
	Test();
	Test(const Test& obj);
	~Test();
	int getMI();

};

//类的定义
Test::Test(int i)
{
	mi = i;
	printf("Test(int i):%d\n",i);
}
Test::Test()
{
	mi = 0;
	printf("Test():%d\n",mi);
}
Test::Test(const Test& obj)
{
	mi = obj.mi;
}
Test::~Test()
{
	printf("~Test()\n");
}
int Test::getMI()
{
	return mi;
}

int main()
{
	const Test t;
	
	printf("mi = %d\n", t.getMI());
	return 0;
}

分析：我们在程序的第42行定义了const 对象 t，而且我们特意把程序写成了先声明后定义的模式。当我们想用const 对象 t 调用getMI（）这个函数时，却突然报错。其原因在于我们上面分析的一点：const 对象只能调用 const 成员函数。所以如何修改呢，只需要在类中的 函数声明 与实际 函数定义 中都必须 const 关键字。只需要在函数声明和定义的后面加一个const 的小尾巴即可。如下面的程序所改：

#include <stdio.h>

class Test		//类的声明
{
private:
	int mi;
public:
	Test(int i);
	Test();
	Test(const Test& obj);
	~Test();
	int getMI()const;

};

//类的定义
Test::Test(int i)
{
	mi = i;
	printf("Test(int i):%d\n",i);
}
Test::Test()
{
	mi = 0;
	printf("Test():%d\n",mi);
}
Test::Test(const Test& obj)
{
	mi = obj.mi;
}
Test::~Test()
{
	printf("~Test()\n");
}
int Test::getMI()const
{
	return mi;
}

int main()
{
	const Test t;
	
	printf("mi = %d\n", t.getMI());
	return 0;
}

小贴士：当我们定义一个const成员变量的时候，我们说它只能用初始化列表进行初始化，不能用构造函数进行赋值，但是当我们定义一个const对象的时候，它里面的成员变量也是不能被修改的，为什么它却可以用构造函数进行赋值呢？

原因：const的含义是当对象第一次构造成功后，就不可以改变。这里const修饰的是对象t，即当对象 t 第一次产生后，就不可以改变。在构造函数的初始化列表阶段，构造函数没有调用完，对象t不受const限制，依旧可以修改。所以我认为是成员变量先构造了然后再加上const属性。

如果mi这个变量具有只读属性，那么我们可以尝试修改它的值。

#include <stdio.h>

class Test		//类的声明
{
private:
	int mi;
public:
	Test(int i);
	Test();
	Test(const Test& obj);
	~Test();
	int getMI()const;
	void setMI(int v)const;
};

//类的定义
Test::Test(int i)
{
	mi = i;
	printf("Test(int i):%d\n",i);
}
Test::Test()
{
	mi = 0;
	printf("Test():%d\n",mi);
}
Test::Test(const Test& obj)
{
	mi = obj.mi;
}
Test::~Test()
{
	printf("~Test()\n");
}
int Test::getMI()const
{
	return mi;
}
void Test::setMI(int v)const
{
	int* p = const_cast<int*>(&mi);
	*p = v;
}
int main()
{
	const Test t;
	
	printf("mi = %d\n", t.getMI());
	
	t.setMI(3);
	printf("mi = %d\n", t.getMI());
	return 0;
}

我们可以发现，在setMI这个函数的声明和定义的末尾加上const才能调用。

其实我们可以发现，在拷贝构造函数里面的参数const Test& obj。其实它的类型在本质上就是const 对象，当我们把拷贝构造函数里的程序改一下会发生什么？

Test::Test(const Test& obj)
{
	//mi = obj.mi;
	mi = obj.getMI();
}
int Test::getMI()
{
	return mi;
}

当我们把第四句换成第三句，程序就不会报错。这是因为第四句里面是用const 对象调用成员函数，但是这个函数并不是const 成员函数。所以修改的话，直接在成员函数后添上const即可。

Test::Test(const Test& obj)
{
	//mi = obj.mi;
	mi = obj.getMI();
}
int Test::getMI()const
{
	return mi;
}

3、关于类成员的疑问

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

回答：每一个对象都有自己的一套成员变量，所有的对象共享一套成员函数

• 从面向对象的角度
  — 对象由属性（成员变量）和方法（成员函数）构成
• 从程序运行的角度
  — 对象由数据和函数构成
  　　　数据可以位于栈，堆和全局数据区
  　　　函数只能位于代码段（代码段是只读）
  所以由于程序的特性，成员函数不可能每个对象都有一套的，所有的对象共享一套成员函数。代码段不能动态的添加和删除
• 结论
  — 每一个对象拥有自己独立的属性（成员变量）
  — 所有的对象共享类的方法（成员函数）
  — 方法能够直接访问对象的属性
  — 方法（成员函数）中的隐藏参数 this 用于指代当前对象

#include <stdio.h>

class Test		//类的声明
{
private:
	int mi;
public:
	Test(int i);
	Test();
	Test(const Test& obj);
	int getMI();
	void print();
};

//类的定义
Test::Test(int i)
{
	mi = i;

}
Test::Test()
{
	mi = 0;

}
Test::Test(const Test& obj)
{
	mi = obj.mi;
}

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

void Test::print()
{
	printf("this = %p\n", this);
}
int main()
{
	Test t1(1);
	Test t2(2);
	Test t3(3);

	printf("&t1 = %p\n", &t1);
	t1.print();
	printf("t1.getMI() = %d\n", t1.getMI());

	printf("&t2 = %p\n", &t2);
	t2.print();
	printf("t2.getMI() = %d\n", t2.getMI());

	printf("&t3 = %p\n", &t3);
	t3.print();
	printf("t3.getMI() = %d\n", t3.getMI());
	return 0;
}

分析：t1对象的地址和成员函数里的 this 指针的地址是一样的，也就是说 this 指针指向当前对象。
成员函数只有一套，它能访问任何所属对象的成员变量。

小结：

• 对象的析构顺序与构造顺序相反
• const 关键字能够修饰对象，得到只读对象
• 只读对象只能调用const成员函数
• 所有对象共享类的成员函数
• 隐藏的this指针指向当前对象