继承和友元,静态成员的关系

5.继承与友元

友元关系不能继承，也就是说基类友元可以访问基类的私有和保护成员,但是不能访问子类私有和保护成员

例如:你爸爸的朋友你不一定认识

class Student;//声明
class Person
{
public:
    //声明Display函数是Person类的友元
    friend void Display(const Person& p, const Student& s);
private:
    string _name;
};
​
class Student: public Person
{
private:
    int _stuid;
};
void Display(const Person& p, const Student& s)
{
    cout << p._name << endl; //可以访问
    cout << s._stuid << endl;//不可以访问
}

若想让Display函数也能够访问派生类Student的私有和保护成员，只能在派生类Student当中进行友元声明

class Student : public Person
{
public:
    //声明Display函数是Student类的友元
    friend void Display(const Person& p, const Student& s);
protected:
    int _stuid; 
};

6.继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的静态成员。无论派生出多少个子类，都只有一 个static成员实例 。

例如:当基类Person中定义了一个静态成员变量count,派生类Student和Teacher都继承了基类Person的成员,但是再整个继承体系中,只有一个静态成员变量count

我们可以通过该静态成员变量count的数值,得知创建的对象个数

由于通过派生类/基类创建一个对象,都需要调用基类的构造函数/拷贝构造函数初始化基类的部分成员,所以我们可以在基类的构造函数/拷贝构造函数中累加_count的值,就可以得知创建了多少个对象

//基类
class Person
{
public:
    //基类的构造函数
    Person()
    {
        ++_count;
    }
    //基类的拷贝构造函数
    Person(const Person& p)
    {
        ++_count;
    }
public:
    static int _count;//静态成员变量
protected:
    string _name;
};
int Person::_count = 0;//静态成员变量在类外初始化
​
//派生类
class Student :public Person
{
private:
    int _stuid;
};
​
//派生类
class Teacher :public Person
{
private:
    int _teaid;
};
void func(Student s)
{}
//可以通过_count的大小得知创建的对象的个数
int main()
{
    Student s1;
    Student s2 = s1;
    Teacher t1;
    Person p;
    func(s1);//传值传参也是一次拷贝构造
    //_count成员是同一个 整个继承体系里面只有一个这样的静态成员
    cout << Person::_count << endl;//5
    cout << Student::_count << endl;//5
    return 0;
}

验证:整个继承体系里面只有一个这样的静态成员

//三者的地址相同
cout << &Person::_count << endl;
cout << &Student::_count << endl;
cout << &Teacher::_count << endl;

\