c++学习小结（10.29封装实现立方体类，点和圆类，对象的初始化和清理）

创建一个圆类和一个点类，判断点和圆的关系

//点
class Point
{
public:
	void setX(int x)
	{
		m_X = x;
	}
	int getX()
	{
		return m_X;
	}
	void setY(int y)
	{
		m_Y = y;
	}
	int getY()
	{
		return m_Y;
	}

private:
	int m_X;
	int m_Y;
};

//圆
class Circle
{
public:
	void setR(int r)
	{
		m_R = r;
	}
	int getR()
	{
		return m_R;
	}
	void setCenter(Point center)
	{
		m_Center = center;
	}
	Point getCenter()
	{
		return m_Center;
	}
private:
	int m_R;
	Point m_Center;
};

//判断点和圆关系函数
void isInCircle(Point &p,Circle &c)
{
	//判断圆心和点的距离
	
	int distance =
		(c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +
		(c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());
	
	//计算半径的平方
	int rDistance = c.getR() * c.getR();

	if (distance == rDistance)
	{
		cout << "点在圆上" << endl;
	}
	else if (distance > rDistance)
	{
		cout << "点在圆外" << endl;
	}
	else
	{
		cout << "点在圆内" << endl;
	}
}
int main()
{
	Circle c;
	c.setR(10);
	Point center;
	center.setX(0);
	center.setY(10);
	c.setCenter(center);

	Point p;
	p.setX(10);
	p.setY(10);

	isInCircle(p, c); //点在圆上
	return 0;
}

创建一个立方体类，判断两个立方体的体积大小

#include<cstdlib>

class Cube 
{
public:
	void setX(int x)
	{
		m_X = x;
	}
	void setY(int y)
	{
		m_Y = y;
	}
	void setZ(int z)
	{
		m_Z = z;
	}
	int getX()
	{
		return m_X;
	}
	int getY()
	{
		return m_Y;
	}
	int getZ()
	{
		return m_Z;
	}

private:
	int m_X;
	int m_Y;
	int m_Z;
};

void isSame(Cube &c1, Cube &c2)
{
	int v1 = c1.getX() * c1.getY() * c1.getZ();
	int v2 = c2.getX() * c2.getY() * c2.getZ();
	if (v1 == v2)
	{
		cout << "体积相等" << endl;
	}
	else if (v1 > v2)
	{
		cout << "v1大" << endl;
	}
	else
	{
		cout << "v2大" << endl;
	}
}
int main()
{
	Cube c1;
	c1.setX(10);
	c1.setY(20);
	c1.setZ(30);
	Cube c2;
	c2.setX(10);
	c2.setY(10);
	c2.setZ(10);

	isSame(c1, c2);

	system("pause");
	return 0;
}

对象的初始化和清理

1.构造函数（初始化）和析构函数（清理）

对象的初始化和清理也是两个非常重要的安全问题

        一个对象或者变量没有初始状态，对其使用后果是未知

        同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用了构造函数和析构函数解决上述问题，这两个函数会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数是空实现。

        构造函数：主要作用于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用

        析构函数：主要作用于对象销毁前系统自动调用，执行一些清理工作。

//对象的初始化和清理
//1.构造函数 

class Person 
{
public:
	//1.1构造函数
	//没有返回值 不用写void
	//函数名与类名相同
	//构造函数可以有参数，可以发生重载
	//创建对象的时候，构造函数会自动调用，而且只调用一次
	Person()
	{
		cout << "Person 构造函数的调用" << endl;
	}

	//2.析构函数 进行清理操作
	//没有返回值 不写void
	//函数名与类名相同 在名称前加 ~
	//析构函数是不可以有参数的，不可以发生重载
	//对象在销毁前，会自动调用析构函数，而且只会调用一次
	~Person()
	{
		cout << "Person 析构函数的调用" << endl;
	}
};
//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现和析构
void test01() 
{
	Person p; //Person 构造函数的调用
              //Person 析构函数的调用
}
//若是在main中Person p，程序会在main完全结束后才执行析构函数
int main()
{
	test01();

	system("pause");
	return 0;
}