Day10（下）.面向对象编程强化

理解面向对象编程的思想，C++的类的概念是把所有的人事物都抽象成一个类，类中定义了人事物的属性和方法，在C++中成为成员变量和成员函数，通过给成员变量赋值，由成员函数进行对成员变量的处理操作返回结果。看下面的代码，深刻理解指针在类中的使用。

#include "iostream"
using namespace std;

class circle
{
private:
	int m_r;
	double m_s;
public:
	int setR(int r)
	{
		return m_r = r;
	}
	double getS()
	{
		return m_s = 3.14*m_r*m_r;
	}
};

int main(int argc, char const *argv[])
{
	int r;
	circle cir;
	cout << "请输入半径：" << endl;
	cin >> r;
	cir.setR(r);
	cout << "圆的半径是" << cir.getS() << endl;

	circle *pcir = ○
	cout << "请输入半径：" << endl;
	cin >> r;
	pcir->setR(r);
	cout << "圆的半径是" << pcir->getS() << endl;

	system("pause");
	return 0;
}

在类的内部定义声明时，一般有public private protected三种，具体这里就不赘述了，可以百度搜索或看书理解，只给出结论。

结论：

1.private修饰的成员变量和成员函数，只能在类的内部使用

2.publix修饰的成员变量和成员函数，能在类的内部和外部使用

3.protected修饰的成员变量和成员函数，在类的外部不能使用，在类的内部能使用（继承中需要用到）

使用时需要注意的是，如果一个成员变量前面不告诉编译器是什么类型， 那么编译器会默认为private，而private的关键字修饰的意思是把类的成员变量隐藏起来。。

看一个例子，求出立方体的面积和体积，show the codes

#include "iostream"
using namespace std;

//目标：抽象立方体 求立方体的s 和 v
class  Cube
{
public:
	void setA(int a)
	{
		m_a = a;
	}
	int getA()
	{
		return m_a;
	}
	void setB(int a)
	{
		m_a = a;
	}
	int getB()
	{
		return m_b;
	}
	void setC(int a)
	{
		m_a = a;
	}
	int getC()
	{
		return m_c;
	}
	void setABC(int a=0, int b=0, int c=0)
	{
		m_a = a;
		m_b = b;
		m_c = c;
	}
public:
	int getS()
	{
		m_s = 2*(m_a*m_b + m_a*m_c + m_b*m_c);
		return m_s;
	}

	int getV()
	{
		m_v = m_a*m_b*m_c;
		return m_v;
	}
public:

	char * cubeEqueal(Cube &c1, Cube &c2)
	{
		if (c1.getA()== c2.getA() &&
			c1.getB()== c2.getB() &&
			c1.getC()== c2.getC())
		{
			return "相等";
		}

		return "不相等";
	}

	char * cubeEqueal(Cube &c2)
	{
		if (m_a== c2.getA() &&
			m_b== c2.getB() &&
			m_c== c2.getC())
		{
			return "相等";
		}

		return "不相等";
	}
private:
	int m_a;
	int m_b;
	int m_c;
	int m_v;
	int m_s;
};

void main()
{
	Cube cube1, cube2, cube3;
	cube1.setABC(1, 2, 3);
	cube2.setABC(2, 3, 4);
	cube3.setABC(1, 2, 3);

	//cout<<cube1.cubeEqueal(cube1, cube2);
	cout<<cube1.cubeEqueal(cube2);
	cout<<cube1.cubeEqueal(cube1);
	
	//cout<<cubeEqueal(cube1, cube2)<<endl;
	//cout<<cubeEqueal(cube1, cube3)<<endl;
	system("pause");
}

void main31()
{
	Cube cube1;
	cube1.setABC(1, 2, 3);
	cube1.getV();
	cube1.getS();
	cout<<"体积为："<<cube1.getV()<<"面积为"<<cube1.getS();

	system("pause");
}

//全局函数
char * cubeEqueal(Cube &c1, Cube &c2)
{
	if (c1.getA()== c2.getA() &&
		c1.getB()== c2.getB() &&
		c1.getC()== c2.getC())
	{
		return "相等";
	}

	return "不相等";
}

void main33()
{
	Cube cube1, cube2, cube3;
	cube1.setABC(1, 2, 3);
	cube2.setABC(2, 3, 4);
	cube3.setABC(1, 2, 3);

	cout<<cubeEqueal(cube1, cube2)<<endl;
	cout<<cubeEqueal(cube1, cube3)<<endl;
	system("pause");
}

例子：输入一点，判断是否在圆内或者圆外

#include "iostream"
using namespace std;


class Point
{
private:
	double x0, y0; //点坐标
public:
	void setPoint(double x, double y)
	{
		x0 = x;
		y0 = y;
	}
	double getX0()
	{
		return x0;
	}
	double getY0()
	{
		return y0;
	}
};

class AdvCircle
{
private:
	double x1, y1; //圆心坐标
	double r1;  //圆半径
public:
	void setCir(double x, double y, double r)
	{
		x1 = x; y1 = y; r1 = r;
	}
public:
	char * judge(double x, double y)
	{
		double s = (x1-x)*(x1-x) + (y1-y)*(y1-y) - r1*r1 ;
		if (s > 0)
		{
			return "在圆外";
		}
		else
		{
			return "在圆内";
		}
	}
	char * judge(Point &p)
	{
		double s = (x1-p.getX0())*(x1-p.getX0()) + (y1-p.getY0())*(y1-p.getY0()) - r1*r1 ;
		if (s > 0)
		{
			return "在圆外";
		}
		else
		{
			return "在圆内";
		}
	}
};

void main()
{
	AdvCircle c1;
	Point p1;
	c1.setCir(2, 2, 3);
	p1.setPoint(1, 1);
	cout<<c1.judge(p1.getX0(), p1.getY0())<<endl;
	cout<<c1.judge(p1)<<endl;
	system("pause");
}

//面向过程编程
void main1()
{
	double x0, y0; //点坐标
	double x1, y1; //圆心坐标
	double r;  //圆半径

	x0 = 1; y0 = 1;
	x1 = 2; y1 = 2;
	r = 3;
	double s = (x1-x0)*(x1-x0) + (y1-y0)*(y1-y0) - r*r ;
	//
	if (s  > 0 )
	{
		cout<<"在圆外";
	}
	else
	{
		cout<<"在圆内";
	}

	system("pause");
}

继续深入，如果我们想把类的定义放在头文件里，而在源文件里进行成员函数的实现，首先分析一下，以点和圆的类说明：

MyCircle.h

#pragma once
#include "MyPoint.h"
class MyCircle
{
public:
    void setCir(double x, double y, double r);
    
public:
    char * judge(double x, double y);
    char * judge(MyPoint &p);

private:
    double x1, y1; //Ô²ÐÄ×ø±ê
    double r1;  //Ô²°ë¾¶
};

MyCircle.cpp

#include "MyCircle.h"

void MyCircle::setCir(double x, double y, double r)
{
	//这里面也是类的内部
	x1 = x; y1 = y; r1 = r;
}

char* MyCircle::judge(double x, double y)
{
	double s = (x1-x)*(x1-x) + (y1-y)*(y1-y) - r1*r1 ;
	if (s > 0)
	{
		return "在圆外";
	}
	else
	{
		return "在圆内";
	}
}

char* MyCircle::judge(MyPoint &p)
{
	double s = (x1-p.getX0())*(x1-p.getX0()) + (y1-p.getY0())*(y1-p.getY0()) - r1*r1 ;
	if (s > 0)
	{
		return "在圆外";
	}
	else
	{
		return "在圆内";
	}
}

MyPoint.h

#pragma once
class MyPoint
{
private:
	double x0, y0; //点坐标
public:
	void setPoint(double x, double y);
	double getX0();
	double getY0();
};

MyPoint..cpp

#include "MyPoint.h"

void MyPoint::setPoint(double x, double y)
{
	x0 = x;
	y0 = y;
}
double MyPoint::getX0()
{
	return x0;
}
double MyPoint::getY0()
{
	return y0;
}

要认真学习面向对象编程的方法和思想。

另外一点需要提及的是空类

class cls
{
public:
private:
protected:
};

int main(int argc, char const *argv[])
{
	cls c;
	printf("size:%d",sizeof(c));
	return 0;
}

答案为1.

结论：空类的对象大小不为0，空类对象具有地址。

C++构造函数

构造函数有有参构造函数、无参构造函数和赋值构造函数（也叫拷贝构造函数）。

其中有参构造函数的调用方法只有下面的三种，show you the codes

#include "iostream"
using namespace std;
//隐式 或 显示 构造函数 析构函数
//
class Test
{
public:

    //有参构造函数
    Test(int a)
    {
        m_a = a;
    }
    //无参数构造函数
    Test()
    {
        m_a = 0;
    }
    //四种应用场景
    //赋值构造函数 copy构造函数
    Test(const Test &obj)
    {

    }

public:
    void print()
    {
        cout<<"m_a："<<m_a<<endl;
    }
protected:
private:
    int m_a;
};

void main()
{
    //括号法
    Test t1(10); //c++编译器自动调用这个类的有参构造函数
    t1.print();

    //=法
    Test t2 = 20; //c++编译器自动调用这个类的有参构造函数
    t2.print();

    //手工调用初始化
    Test t3 = Test(30);//程序员手工的调用构造函数 进行对象初始化
    t3.print();

    system("pause");
}

一定要多练，多练！！！！！！！多练！！！！！！！多练！！！！！！！