掘根宝典之C++抽象基类，protected，纯虚函数

关键字protected

关键字protected和private相似，在类外只能用公有类成员来访问protected部分的成员。

#include<iostream>
using namespace std;
class AA
{
protected:
	int a_;
public:
	AA(int a):a_(a){}
	void A()
	{
		cout << a_ << endl;
	}
};
int main()
{
	AA r(2);
	r.a_ = 3;//这是不行的
	r.A();//结果是2
}

private和protected的区别只有在基类派生出的类里才会体现出来。派生类的成员可以直接访问基类的保护成员，但是不能直接访问基类的私有成员。因此对于外部世界来说，保护成员的行为与私有成员类似；但对于派生类来说，保护成员的行为和公有成员类似

protected:

#include<iostream>
using namespace std;
class AA
{
protected:
	int a_;
public:
	AA(int a):a_(a){}
	void A()
	{
		cout << a_ << endl;
	}
};
class BB :public AA
{
protected:
	int b_;
public:
	BB(int a,int b):AA(a),b_(b){}
	void A()
	{
		cout << a_ << endl;///可以直接访问基类的protected
	}
};
int main()
{
	BB r(2,3);
	
	r.A();
}

 private:

#include<iostream>
using namespace std;
class AA
{
private:
	int a_;
public:
	AA(int a):a_(a){}
	void A()
	{
		cout << a_ << endl;
	}
};
class BB :public AA
{
protected:
	int b_;
public:
	BB(int a,int b):AA(a),b_(b){}
	void A()
	{
		cout << a_ << endl;//不可以直接访问基类的private
	}
};
int main()
{
	BB r(2,3);
	
	r.A();
}

惯例：我们通常将数据成员设置为private，把部分类方法设置为protected

纯虚函数

不懂虚函数的看这里http://t.csdnimg.cn/qgl94

在C++中，纯虚函数（Pure Virtual Function）是一种在基类中声明但没有实现的虚函数。纯虚函数的声明形式为在纯虚函数声明后面加上= 0，表示该函数没有具体的实现。

在类声明中包含纯虚函数时，不能创建该类的对象（包含纯虚函数的类只能作基类）

纯虚函数的主要作用是为了定义一个接口，在基类中声明纯虚函数后，派生类必须实现这个函数，否则派生类也会成为抽象类。纯虚函数使得基类能够定义一些通用的接口或行为，而将具体的实现交给派生类来完成。

下面是一个示例代码：

class Shape {
public:
    virtual double area() const = 0;  // 纯虚函数
};

class Rectangle : public Shape {
public:
    double area() const {
        // 实现具体的计算逻辑
        return length * width;
    }
private:
    double length;
    double width;
};

class Circle : public Shape {
public:
    double area() const {
        // 实现具体的计算逻辑
        return 3.14159 * radius * radius;
    }
private:
    double radius;
};

在上述代码中，Shape是一个抽象基类，它包含一个纯虚函数area()。Rectangle和Circle是Shape的派生类，它们必须实现area()函数。

纯虚函数只提供了一个函数的声明，没有具体的实现。因此，不能直接实例化一个包含纯虚函数的类对象，只能通过派生类来使用。对于包含纯虚函数的类来说，它们被称为抽象类，不能创建对象实例。只有派生类实现了所有纯虚函数，才能创建对象实例。

抽象基类

在C++中，抽象基类（Abstract Base Class）是一种特殊的类，它只用于作为其他类的基类，而不能直接实例化对象。抽象基类的主要目的是定义一个通用的接口，而不关心具体的实现细节。

抽象基类通常包含纯虚函数（Pure Virtual Function），这是一种没有实际实现的函数，在抽象基类中只是声明而没有定义。子类必须实现这些纯虚函数，否则子类也会成为抽象类。例如：

class Shape {
public:
    virtual double area() const = 0;  // 纯虚函数
};

class Rectangle : public Shape {
public:
    double area() const {
        // 实现具体的计算逻辑
        return length * width;
    }
private:
    double length;
    double width;
};

class Circle : public Shape {
public:
    double area() const {
        // 实现具体的计算逻辑
        return 3.14159 * radius * radius;
    }
private:
    double radius;
};

在上述例子中，Shape是一个抽象基类，它包含一个纯虚函数area()，子类Rectangle和Circle都需要实现这个函数。当我们使用抽象基类的指针或引用时，可以通过动态绑定的方式调用子类的实现。

Shape* shape;
Rectangle rect;
Circle circle;

shape = ▭
double rectArea = shape->area();  // 调用Rectangle的area函数

shape = &circle;
double circleArea = shape->area();  // 调用Circle的area函数

抽象基类的使用可以提供一种接口的统一标准，使得不同的子类能够以相同的方式进行使用和处理。