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

男娘i 2022-08-01 12:23 143阅读 0赞

理解面向对象编程的思想，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");
    }

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