day12_ Const 成员

Const 成员

• const成员:被const修饰的成员变量、非静态成员函数

• const成员变量

  • 必须初始化(类内部初始化)，可以在声明的时候直接初始化赋值
  • 非static的const成员变量还可以在初始化列表中初始化

• const成员函数(非静态)

  • const关键字写在参数列表后面，函数的声明和实现都必须带const
  • 内部不能修改非static成员变量
  • 内部只能调用const成员函数、static成员函数
  • 非const成员函数可以调用const成员函数
  • const成员函数和非const成员函数构成重载
  • 非const对象(指针)优先调用非const成员函数
  • const对象(指针)只能调用const成员函数、static成员函数

class Car {
public:
	int m_price;
	// static const int msc_wheelsCount = 4;

	Car() :m_price(0) {

	}

	static void test3() {

	}

	void test4() {
		test1();
	}

	void test2() const {
		// this->m_price = 20;
	}

	// 不能在这个函数内部修改当前对象的成员变量
	void test1() const {
		// this->m_price = 10;

		test2();
		test3();
	}

	void test() {
		cout << "test()" << endl;
	}

	void test() const {
		cout << "test() const" << endl;
	}
};

int main() {
	Car car;
	car.test();

	Car *p = new Car();
	p->test();

	const Car car2;
	car2.test();

	const Car *p2 = new Car();
	p2->test();

	/*Car car1;
	car1.m_price = 100;

	Car car2;
	car2.m_price = 500;

	cout << sizeof(Car) << endl;*/

	getchar();
	return 0;
}

拷贝构造函数Copy Constructor

• 拷贝构造函数是构造函数的一种
• 当利用已存在的对象创建一个新对象时(类似于拷贝)，就会调用新对象的拷贝构造函数进行初始化
• 拷贝构造函数的格式是固定的，接收一个const引用作为参数

class Car {
	int m_price;
	int m_length;

public:
	Car(int price = 0, int length = 0) :m_price(price), m_length(length) {
		cout << "Car(int price = 0, int length = 0)" << endl;
	}

	// 拷贝构造函数（格式是固定的）
	Car(const Car &car) :m_price(car.m_price), m_length(car.m_length) {
		// this->m_price = car.m_price;
		// this->m_length = car.m_length;

		cout << "Car(const Car &car)" << endl;
	}

	void display() {
		cout << "price=" << this->m_price << ", length=" << this->m_length  << endl;
	}
};

class Person {
	int m_age;
public:
	Person(int age = 0) :m_age(age) { }
	Person(const Person &person) :m_age(person.m_age) { }
};

class Student : public Person {
	int m_score;
public:
	Student(int age = 0, int score = 0) :Person(age), m_score(score) { }
	Student(const Student &student) :Person(student), m_score(student.m_score) { }
};

int main() {
	//Car car1;

	//Car car2(100, 5);

	//// 利用car2对象创建了car3对象，会调用car3对象的拷贝构造函数进行初始化
	//Car car3(car2);
	//car3.display();

	//cout << "&car2 = " << &car2 << endl;
	//cout << "&car3 = " << &car3 << endl;

	// Car car2(100, 5);
	// Car car3 = car2; // 等价于Car car3(car2)

	//Car car2(100, 5);
	//Car car3;
	// 这里是赋值操作，直接将car2的8个字节数据拷贝给car3的8个字节
	// 但这并不是创建新对象，所以不会调用拷贝构造函数
	//car3 = car2;
	// car3.m_price = car2.m_price;
	// car3.m_length = car2.m_length;

	getchar();
	return 0;
}

浅拷贝、深拷贝

• 编译器默认的提供的拷贝是浅拷贝(shallow copy)
  • 将一个对象中所有成员变量的值拷贝到另一个对象
  • 如果某个成员变量是个指针，只会拷贝指针中存储的地址值，并不会拷贝指针指向的内存空间
  • 可能会导致堆空间多次free的问题
• 如果需要实现深拷贝(deep copy)，就需要自定义拷贝构造函数
  • 将指针类型的成员变量所指向的内存空间，拷贝到新的内存空间

using namespace std;

// 浅拷贝（shallow copy）：指针类型仅仅是拷贝地址值
// 深拷贝（deep copy）：拷贝内容到新申请的内存空间

class Car {
	int m_price;
	char *m_name;

public:
	Car(int price = 0, const char *name = NULL) :m_price(price) { 
		if (name == NULL) return;

		// 申请堆空间存储字符串内容
		this->m_name = new char[strlen(name) + 1]{};
		// 拷贝字符串内容到堆空间(string copy)
		strcpy(this->m_name, name);

		cout << "Car(int, const char *)" << endl;
	}

	Car(const Car &car) :m_price(car.m_price) {
		if (car.m_name == NULL) return;

		// 申请堆空间存储字符串内容
		this->m_name = new char[strlen(car.m_name) + 1]{};
		// 拷贝字符串内容到堆空间(string copy)
		strcpy(this->m_name, car.m_name);

		cout << "Car(const Car &car)" << endl;
	}

	~Car() {
		if (this->m_name == NULL) return;

		delete[] this->m_name;
		this->m_name = NULL;

		cout << "~Car()" << endl;
	}

	void display() {
		cout << "price is " << this->m_price << ", name is " << this->m_name << endl;
	} 
};


int main() {
	/*char name[] = { 'b', 'm', 'w', '\0' };
	Car *car = new Car(100, name);
	car->display();
	delete car;*/


	Car car1(100, "bmw");

	// 将car1的内存空间（8个字节）覆盖car2的内存空间（8个字节）
	Car car2 = car1;

	cout << endl;


	// Car car(100, "bmw");


	//char name[] = { 'b', 'm', 'w', '\0' };
	//const char *name2 = "bmw";

	//cout << name2 << endl;

	//// string length
	//cout << strlen(name) << endl;

	getchar();
	return 0;
}