C/C++、Java、Go、Python总结对比13-public、protect和private使用-c++

本文链接：https://blog.csdn.net/aeoob/article/details/90732281

在面向对象的语言中，这3个关键词应该都是要用到。虽然c++、java、go、python都是面向对象的语言，但是语法和用法都有或多或少的区别，并不能学一门语言就能学会其他多门语言，他们的区别还是需要区分清楚的。

（总有人说学会一门语言就其他语言都会了，千万不要信！如果真是这样的话，那一种语言就能一统天下了，别人闲的没事干发明这么多语言。只能说学会一门语言后有了编程基础，学其他语言会上手快一些而已！）

一篇文章介绍不完，这里就先介绍c++中这3个关键词的使用。

学习这件事还是要站在巨人的肩膀上，本文也是借鉴了这篇文章https://blog.csdn.net/ycf74514/article/details/49053041

成员的访问权限

1 public访问权限

public修饰的成员变量和成员函数，类内的成员函数和类的实例变量可访问。

实际上，类的成员函数，可以访问本类内的任何成员变量和成员函数。

#include<iostream>
#include<string>

using namespace std;

class AccessTest
{
public:
    int pub_mem;
    int pub_fun(){};
protected:
    int prot_mem;
    int prot_fun(){};
private:
    int priv_memb;
    int priv_fun(){};

};

int main()
{
    AccessTest at;
    at.pub_mem;     //OK, 类变量可以访问public成员
    at.pub_fun();  //OK, 访问public成员函数是没有问题的

    return 0;
}

2 protected访问权限

protected修饰的成员变量、成员函数，类的实例变量无法访问。但是可以通过类的友元函数、友元类进行访问。

#include<string>
#include<iostream>

using namespace std;

class AccessTest {
    friend void Atest();
    friend class CAtest;

public:
    int pub_mem;
    void pub_fun() {}

protected:
    int prot_mem;
    void prot_fun() {}

private:
    int priv_memb;
    void priv_fun() {}

};

class CAtest {
public:
    void x() {
        AccessTest t;
        t.prot_fun();  //OK,友元类可以访问protected成员函数
        int x = t.prot_mem; //OK,友元类可以访问protected成员变量
    }
};

void Atest() {
    AccessTest t;
    t.prot_fun(); //OK,友元函数可以访问protected成员函数
    int x = t.prot_mem; //OK,友元函数可以访问protected成员变量
}

int main() {
    AccessTest at;
    at.prot_mem; //ERROR,类实例变量无法访问protected成员变量
    at.prot_fun(); //ERROR,类实例变量无法访问protected成员函数
    Atest();
    return 0;
}

3 private访问权限

private成员变量、成员函数，无法通过类的实例变量进行访问。但是可以通过类的友元函数、友元类进行访问。

#include<iostream>
#include<string>

using namespace std;

class AccessTest {
    friend void Atest();
    friend class CAtest;

public:
    int pub_mem;
    void pub_fun() {}

protected:
    int prot_mem;
    void prot_fun() {}

private:
    int priv_memb;
    void priv_fun() {}

};

class CAtest {
public:
    void x() {
        AccessTest t;
        t.priv_fun();       //OK,友元类可以访问private成员函数
        int x = t.priv_memb;  //OK,友元类可以访问private成员变量
    }
};

void Atest() {
    AccessTest t;
    t.priv_fun();       //OK,友元函数可以访问private成员函数
    int x = t.priv_memb;  //OK,友元函数可以访问private成员变量
}

int main() {
    AccessTest at;
    at.priv_memb;       //ERROR,类实例变量无法访问private成员变量
    at.priv_fun();      //ERROR,类实例变量无法访问private成员函数
    Atest();
    return 0;
}

从上面来看，protected和private没有区别。区别主要体现在继承上面。后面会讲。

一句话总结：public在任何地方都能访问。proteted和private不能被实例访问，但可以被友元函数访问。

继承的访问权限控制

c++的类继承分为public、protected和private继承，不像java那样只有一种继承。

1 public继承

派生类通过public继承，基类的各种权限不变。

派生类的成员函数，可以访问基类的public成员、protected成员，但是无法访问基类的private成员。

派生类的实例变量，可以访问基类的public成员，但是无法访问protected、private成员，仿佛基类的成员之间加到了派生类一般。

#include <iostream>
#include <string>

using namespace std;

class AccessTest {
public:
    int pub_mem;
    void pub_fun(){}

protected:
    int prot_mem;
    void prot_fun(){}

private:
    int priv_mem;
    void priv_fun(){}
};

class DAccessTest:public AccessTest {
public:
    void test() {
        int x=pub_mem;     //OK
        pub_fun();         //OK

        int y=prot_mem;    //OK
        prot_fun();        //OK

        int z=priv_memb;   //ERROR
        priv_fun();        //ERROR
    }
};

int main() {
    DAccessTest dt;
    int x = dt.pub_mem;
    int y=dt.prot_mem;   //ERROR
    int z=dt.priv_memb;  //ERROR
    return 0;
}

一句话总结：public继承看成派生类将基类的public,protected成员囊括到派生类，但是不包括private成员。

2 protected继承

派生类通过protected继承，基类的public成员在派生类中的权限变成了protected 。protected和private不变。

派生类的成员函数，可以访问基类的public成员、protected成员，但是无法访问基类的private成员。

派生类的实例变量，无法访问基类的任何成员，因为基类的public成员在派生类中变成了protected。

#include<iostream>
#include<string>

using namespace std;

class AccessTest {
    friend void Atest();
    friend class CAtest;

public:
    int pub_mem;
    void pub_fun() {}

protected:
    int prot_mem;
    void prot_fun() {}

private:
    int priv_memb;
    void priv_fun() {}

};

class DAccessTest : protected AccessTest {
public:
    void test() {
        int x = pub_mem; //OK
        pub_fun(); //OK

        int y = prot_mem; //OK
        prot_fun(); //OK

        int z = priv_memb; //ERROR
        priv_fun(); //ERROR
    }

};


int main() {
    DAccessTest dt;
    int x = dt.pub_mem; //ERROR，基类的成员现在是派生类的保护成员
    int y = dt.prot_mem; //ERROR，基类的成员现在是派生类的保护成员
    int z = dt.priv_memb; //ERROR
    return 0;
}

一句话总结：可将protected继承看成派生类将基类的public,protected成员囊括到派生类，全部作为派生类的protected成员，但是不包括private成员。

3 private继承

派生类通过private继承，基类的所有成员在派生类中的权限变成了private。

派生类的成员函数，可以访问基类的public成员、protected成员，但是无法访问基类的private成员。

派生类的实例变量，无法访问基类的任何成员，因为基类的所有成员在派生类中变成了private。

#include<iostream>
#include<string>

using namespace std;

class AccessTest
{
    friend void Atest();
    friend class CAtest;
public:
    int pub_mem;
    void pub_fun(){}
protected:
    int prot_mem;
    void prot_fun(){}
private:
    int priv_memb;
    void priv_fun(){}

};

class DAccessTest:private AccessTest
{
public:
    void test()
    {
        int x=pub_mem;     //OK
        pub_fun();         //OK

        int y=prot_mem;    //OK
        prot_fun();        //OK

        int z=priv_memb;   //ERROR
        priv_fun();        //ERROR
    }

};



int main()
{
    DAccessTest dt;
    int x=dt.pub_mem;    //ERROR，基类的成员现在是派生类的私有成员
    int y=dt.prot_mem;   //ERROR，基类的成员现在是派生类的私有成员
    int z=dt.priv_memb;  //ERROR, private成员无法访问
    return 0;
}

一句话总结：可以将private继承看成派生类将基类的public,protected成员囊括到派生类，全部作为派生类的private成员，但是不包括private成员。