【C/C++语言】class的定义和基础用法

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

这篇文章中记录一些C/C++中class的相关知识

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、如何构造一个class

1.创建一个立方体类

• private: 三个私有变量（长、宽、高）
• public: 变量的输入输出方法以及计算表面积和体积的方法

//定义一个立方体的类，这个类中有三个私域变量长、宽、高，然后还有输入输出长宽高、计算表面积和体积八个方法
class Cube {//类名
	//定义私有变量
    private:
        int length, width, height;//长、宽、高
    //定义方法
    public:
        //构造方法
        //初始化长、宽、高，将外界传入的参数值
        //设置到私有变量中
        void setLength(int len) {length = len;}
        void setWidth(int wid) {width = wid;}
        void setHeight(int hei){height = hei;}
		//除了上述方法外，还可以通过构造函数来实现初始化，两者是等价
		Cube(int length, int width, int height) {//这样在例化Cube时如果传入参数值就会自动给私有变量赋值
			this->length = length;
            this->width = width;
            this->height = height;
		}

        //如果需要知道类中私有变量的值，可以调用以下方法获得
        int getLength() {return length;}
        int getWidth()  {return width; }
        int getHeight() {return height;}
        //获取表面积
        int getArea() {
            return 2 * (length * width + length * height + height * width);
        }
        //获取体积
        int getVolume() {
            return length * width * height;
        }
};

2.在main函数中调用class

• 内容：实现例化Cube，传入参数值并计算表面积和体积的功能

int main() {
    int length, width, height;
    //获取输入
    cin >> length;
    cin >> width;
    cin >> height;
	/*可以采用调用自定义函数的方式来初始化
    Cube c;
    c.setLength(length);
    c.setWidth(width);
    c.setHeight(height);
	*/
	//如果采用构造函数可以把上述代码简化为
	Cube c(length, width, height);
    cout << c.getLength() << " "
        << c.getWidth() << " "
        << c.getHeight() << " "
        << c.getArea() << " "
        << c.getVolume() << endl;

    return 0;
}

---

二、友元函数

• 友元函数使用friend关键字声明；
• 其作用是在类外访问一个类的私有变量，是为了方便不同类之间数据共享而出现的
• 例如定义了一个点类，希望求两个点之间的距离，这个时候就需要一个友元函数能够同时访问这两个点类的私有数据成员来进行计算

#include <iostream>
#include <math>
using namespace std;

class point {
	public:
		//构造函数
		point(int x=0, int y=0): x(x), y(y) {};
		
		int getx() {return x;}
		int getY() {return y;}
		//使用friend关键字声明友元函数
		//并传入两个点类参数
		friend float dist(point &pl, point &p2);
		
	private:
		//私有数据成员
		int x, y;
};
//在类外定义友元函数
float dist(point &pl, point &p2) {//求两个点之间的距离
	double x = p1.x - p2.x;//可以直接调用类中的私有变量
	double y = p1.y - p2.y;
	return static_cast<float>(sqrt(x * x + y * y));
}

int main() {
	//例化两个point类的对象并传入相应参数
	point myp1(1, 1), myp2(4, 5);
	cout << "the distance is:";
	//计算两点间的距离
	cout << dist(myp1, myp2) << endl;
	return 0;
}

三、运算符重载

• 如果需要定义一个Time类包含hour和minute两个参数，并将两个类中的时间进行 + 运算是不可以的；
• 因为原生+运算不支持运算两个class，这个时候需要重载+的功能，按照自己需求编写一个可以运算类的+函数

//重载要用关键字operator
#include <iostream>
using namespace std;

class Time {
    public:
        int hours;      // 小时
        int minutes;    // 分钟
        //构造函数初始化
        Time(int h, int m) {
            this->hours = h;
            this->minutes = m;
        }
        void show() {//输出功能
            cout << hours << " " << minutes << endl;
        }

        //方法一，在类中采用成员函数的方法实现，
        //由于加法是对两个数相加，在类中可以调用自身的变量，再传入一个变量就可以相加了
        Time operator+(Time &t) {//opeartor重载+号，并传入一个Time参数
            Time sum;//存储相加后的新类
            sum.hours = this->hours + t.hours + (this->minutes + t.minutes) / 60;//按照数学运算方法对小时和分钟进行运算
            sum.minutes = (this->minutes + t.minutes) % 60;
            return sum;//计算完后返回结果
        }
		//方法二是采用友元函数重载，由于友元函数定义在类外，需要传入两个类参数，这两种方法是等价的
		friend Time operator+(Time& t, Time& m) {}
};
//在类外定义友元函数
Time operator+(Time& t, Time& m) {
	Time sum;//存储相加后的结果
    sum.hours = t.hours + m.hours + (t.minutes + m.minutes) / 60;
    sum.minutes = (t,minutes + m.minutes) % 60;
    return sum;//计算完后返回
}

int main() {
    Time t1(1, 50);
    Time t2(2, 20);
	//进行加法运算
    Time t3 = t1 + t2;
    t3.show();
    //打印的结果是 4 10
    return 0;
}

四、派生子类

• C++支持从父类中派生子类，子类可以继承父类中所有的变量和方法，还可以自己定义新的变量和方法，还支持对原有的方法重载出新的功能；
• 如果需要定义很多有公共变量和方法的类，则可以将公共变量和方法定义成父类，再派生出子类各自定义新的变量和方法；
• 以下这个例子就定义了父类Base，并派生出子类Sub，还在子类中重载父类的calucate函数

#include <iostream>
using namespace std;

class Base {
    private:
        int x;
        int y;

    public:
        Base(int x, int y) {
            this->x = x;
            this->y = y;
        }

        int getX() {return x;}
		int getY() {return y;}
		//推荐将需要重载的函数定义为virtual类型，如果漏掉了好像也不会报错
		virtual int calculate() {
        	return getX() * getY();
    	}
};

class Sub : public Base {//:表示派生关系
    private:
        int z;    
    public:
        Sub(int x, int y, int z) : Base(x, y) {//：表示从父类继承x和y两个变量的初始化方法，再对额外增加的变量z进行初始化
            this->z = z;
        }

        int getZ() {return z;}
        //将需要重载的函数也定义为virtual类型，实现三个变量相乘
		virtual int calculate() {
            return Base::getX() * Base::getY() * this->getZ();
        }
};

int main() {

    int x, y, z;
    cin >> x;
    cin >> y;
    cin >> z;
    //例化子类
    Sub sub(x, y, z);
    //调用函数计算并输出
    cout << sub.calculate() << endl;  
    return 0;
}

五、多态特性

由于父类中函数是可以重载的，因此一个函数在不同的子类中可以重载出不同的功能；

class BaseCalculator {
    public:
        int m_A;
        int m_B;
        // 提供一个getResult函数，然后在不同的子类中写不同的功能
        virtual int getResult() = 0;
        
};

// 加法计算器类
class AddCalculator : public BaseCalculator {
    public:
        virtual int getResult() {
            return m_A + m_B; 
        }
};
// 减法计算器类
class SubCalculator : public BaseCalculator {
    public:
        virtual int getResult() {
            return m_A - m_B; 
        }
};

int main() {
	//例化加法计算器变量
    BaseCalculator* cal = new AddCalculator;
    cal->m_A = 20;
    cal->m_B = 10;
    //结果是30
    cout << cal->getResult() << endl;
    delete cal;

    cal = new SubCalculator;
    cal->m_A = 20;
    cal->m_B = 10;
    //结果是10
    cout << cal->getResult() << endl;
    delete cal;
    return 0;
}