c++虚函数和纯虚函数以及static关键字

c++的多态以及虚函数，纯虚函数都是面试常问的问题
所以我今天专门更新一篇关于c++的虚函数和纯虚函数的博文

虚函数的语法

在类成员方法的声明语句之前加上virtual 他就会变成虚函数
在虚函数的声明语句末尾加上**=0** 他就会变成纯虚函数
子类可以重新定义基类的虚函数 （复写，重写）在之前的unity开发中我也经常用到多态
不管是虚函数还是纯虚函数，基类都可以提供其的实现，
子类可以自主选择是否提供一份属于自己的个性虚函数的实现
子类必须提供属于自己的纯虚函数的实现，否则编译失败会产生报错

下面我们举一个很长很长的例子，帮助大家理解多态以及两种虚函数

假设我们要设计一个汽车的类，不同的汽车有不同的发动机类型
并且我们有一位老师傅 会开各种车 火车 小轿车等等

class car {
	//小汽车的基类
	virtual void move();//移动
	virtual void refuel()= 0;//加油
};
void car::move() {
	cout << "陆地行走" << endl;
}
void car::refuel() {
	cout << "加汽油" << endl;
}

上边我们声明了一个小汽车的类 默认陆地行走 加汽油
然后其中的move我将其设置为虚函数，refuel设置为纯虚函数

class truck : public car {
	//不用重写move  默认陆地行走
	void refuel() {
		cout << "加柴油" << endl;
	}
};
class ship :public car {
	void move() {
		cout << "水面移动" << endl;
	}
	void refuel() {
		cout << "加柴油" << endl;
	}
};

然后我们写两个类继承car 一个货车，一个轮船
由于refuel是纯虚函数 所以每一个子类必须重写refuel类 这是必须的

class driver {
	//司机类
	void refuel(car* p) {
		cout << "司机给";
		p->refuel();
	}
	void drive(car* p) {
		cout << "载具移动方式";
		p->move();
	}
};

然后我们声明一个司机的类

int main() {
	car* jiaolong_ship = new ship();//蛟龙号
	car* big_truck = new truck();//大卡车

	driver mike;
	mike.drive(jiaolong_ship);
	mike.refuel(jiaolong_ship);

	cout << "-----------------------------------" << endl;
	mike.drive(big_truck);
	mike.refuel(big_truck);
	return 0;
}

然后我们在main函数中调用

运行截图

上边体现了所谓多态的场景，给mike不同的载具，就能表现不同的效果

虚函数和纯虚函数都可以做到这点，但是就在于子类是否必须提供虚函数的实现

然后我给出上述源码

class car {
	//小汽车的基类
public :
	virtual void move();//移动
	virtual void refuel()= 0;//加油
};
void car::move() {
	cout << "陆地行走" << endl;
}
void car::refuel() {
	cout << "加汽油" << endl;
}

class truck : public car {
	//不用重写move  默认陆地行走
	void refuel() {
		cout << "加柴油" << endl;
	}
};
class ship :public car {

	void move() {
		cout << "水面移动" << endl;
	}
	void refuel() {
		cout << "加柴油" << endl;
	}
};

class driver {
public:
	//司机类
	void refuel(car* p) {
		cout << "司机给载具";
		p->refuel();
	}
	void drive(car* p) {
		cout << "载具移动方式:";
		p->move();
	}
};
int main() {
	car* jiaolong_ship = new ship();//蛟龙号
	car* big_truck = new truck();//大卡车

	driver mike;
	mike.drive(jiaolong_ship);
	mike.refuel(jiaolong_ship);

	cout << "-----------------------------------" << endl;
	mike.drive(big_truck);
	mike.refuel(big_truck);
	return 0;
}

static关键字

作用于函数内部的局部变量

当一个函数返回之后，下一次再次调用的时候，这个变量还会保持上一次执行之后的值
函数内部的静态变量只开辟一次空间，而且不会因为多次调用而产生副本，也不会因为函数返回而失效

不加static关键字

void test(){
	int count = 0;
	cout << "count:" << count<<endl;
	count++;
}
int main() {
	cout << "第一次:" << endl;
	test();
	cout << "第二次:" << endl;
	test();
	return 0;
}

加上static关键字

void test(){
	static int count = 0;
	cout << "count:" << count<<endl;
	count++;
}
int main() {
	cout << "第一次:" << endl;
	test();
	cout << "第二次:" << endl;
	test();
	return 0;
}

可以看到两次运行结果的差别

另外
普通局部变量如果没有赋值初值 编译器会报错

但是加上static之后，定义未初始化，编译器默认赋值为0；

作用于类的成员，解决一个类的不同该对象之间的数据和函数共享的问题

当static作用于类的数据成员的时候，就使其变成一个静态数据成员，

访问静态数据成员方式：类名::标识符
对静态数据成员初始化必须在类之外进行

如果直接在类中给静态成员赋值，会发生报错

int a = 0;
static int b = 0;

正确做法

class test {
	int a = 0;
	static int b;
};
int test::b = 100;

如果在类外调用静态成员函数
访问方式：一般通过类名：：函数名调用，也可用类.函数名调用

总结

基类提供的纯虚函数的实现，并非为了多态性考虑，因为指向子类对象的基类指针和引用无法调用该版本，纯虚函数在基类中的实现和多态性无关，知识提供语法上的遍历

虚函数和普通的函数存储在不同的区域，虚函数的区域是可以被重写的
而普通函数的存储区域不会被覆盖，每个函数都有自己的区域互不相干

static作用于非类内函数的局部变量的时候，每次函数调用不会随着函数返回而失效
当static作用于类内的成员的时候，有该类全部对象共同维护和使用，从而实现同一个类不同的数据对象共享

希望我所写的对大家有所帮助