C++

/*
//4-9

#include<iostream>
using namespace std;
class Rectangle {   // 设计一个矩形类
public:
	void setX1(int x1)
	{
		m_X1 = x1;
	}
	int getX1() {
		return m_X1;
	}
	void setY1(int y1) {
		m_Y1 = y1;
	}
	int getY1() {
		return m_Y1;
	}
	void setX2(int x2) {
		m_X2 = x2;
	}
	int getX2() {
		return m_X2;
	}
	void setY2(int y2) {
		m_Y2 = y2;
	}
	int getY2() {
		return m_Y2;
	}
private:
	int m_X1;
	int m_Y1;
	int m_X2;
	int m_Y2;
};
void calculateS(Rectangle& R) {

	int S = (R.getX2() - R.getX1()) * (R.getY2() - R.getY1());
	cout << S << endl;
}


int main() {


	Rectangle R;
	R.setX1(10);
	R.setY1(10);
	R.setX2(15);
	R.setY2(15);
	calculateS(R);
	return 0;

}

//4-8
#include<iostream>
using namespace std;
class Dog {
public:
	void setAge(int age)
	{
		m_age = age;
	}
	int getAge()
	{
		return m_age;
		
	}
	void setWeight(int weight)
	{
		m_weight = weight;
	}
	int getWeight()
	{
		return m_weight;
	}
private:
	int m_age; //成员属性
	int m_weight;



};


int main() {
	
	Dog A;  //创建对象
	
	A.setAge(10);   
	A.setWeight(50);
	cout << "狗的年龄为：" << A.getAge() <<"狗的体重为："<< A.getWeight()<<endl;
	return 0;
}

```java
class Person {
public:
	//构造函数格式：：
	// 类名（）{}
	Person()
	{
		cout << "person的无参构造函数的调用" << endl;
	}
	Person(int a)
	{

		age = a;
		cout << "person的有惨构造函数的调用" << endl;

	}
	//拷贝构造函数
	Person(const Person& p) //const起限定作用
	{
		age = p.age;

	}
	int age;
};

```java
//调用
void test01()
{
	//1 括号法--调用默认构造函数时，不要加（）
	Person p;//默认构造函数的调用
	Person p2(10);//有参构造
	Person p3(p2);


	//2显示法
	Person p1;
	Person p3 = Person(10);

	Person(10);   //匿名对象
	//不要利用拷贝构造函数 初始化匿名对象


	//隐式转换法

	Person p4 = 10;   //相当与 Person p4 = Person (10;

}

4:构造函数的调用规则

1如果定义了有参构造函数，C++不在提供默认无参构造，但是会提供默认拷贝构造
2：如果定义了拷贝构造函数，C++不会再提供其他构造函数

深拷贝与浅拷贝
浅拷贝：简单的赋值拷贝操作
深拷贝：在堆内存重新申请空间进行拷贝操作

*/

#include<iostream>
using namespace std;
class Person {

public:


	//默认的无参构造函数
	Person() {

		cout << "无参构造函数" << endl;
	}
	//有参构造函数
	Person(int age, int heigth) {
		cout << "有参构造函数" << endl;
		m_age = age;
		m_heigth = new int(heigth);
	}
	//拷贝构造函数
	Person(const Person& p) {
		cout << "拷贝构造函数" << endl;
		m_age = p.m_age;
		m_heigth = new int(*p.m_heigth);
	}
	~Person() {
		cout << "析构函数" << endl;
		if (m_heigth != NULL) {
			delete m_heigth;
		}
	}
	int m_age;
	int* m_heigth;
};

void test01() {
	Person p1(18, 160);
	Person p2(p1);
	cout << "p1的年龄为" << p1.m_age << "身高：" << *p1.m_heigth << endl;
	cout << "p2的年龄为" << p2.m_age << "身高：" << *p2.m_heigth << endl;
}
int main() {
	test01();
	return 0;
}

//如果属性有在堆区开辟，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

5：//初始化列表

#include<iostream>
using namespace std;
class Person {

public :
	int m_A;
	int m_B;
	int m_C;
	//传统初始化
	/*Person(int a, int b, int c) {
		m_A = a;
		m_B = b;
		m_C = c;
		
	}
	*/

	//初始化列表初始化属性
	Person(int a,int b,int c ):m_A(10), m_B(20), m_C(30){ }

 };
void  test01()//测试类
{
	//Person p(10, 20, 30);  //创建对象
	Person p(10,20,30);
	cout << "m_A=:" << p.m_A << endl;
	cout << "m_B=:" << p.m_B << endl;
	cout << "m_C=:" << p.m_C << endl;
}
int main() {
	test01();
	return 0;


}