C++：C++中public protected private关键字用法

谁借莪１个温暖的怀抱￠ 2022-12-22 13:30 176阅读 0赞

# C++：C++中public protected private关键字用法 #

笔者这里主要针对C++中public protected private关键字做一个较全面的总结。**首先public protected private关键字用于访问控制的，也被称为访问说明符**。

主要用途有2种。

*  **用法1：在class类**(含struct结构体，struct在C++中是所有成员都公开的类)**中 作为成员变量/成员函数的修饰符**。
 *  **用法2：在C++的继承体系中作为从继承修饰符使用**。

下面我们分开进行介绍。

## 在class类中 ##

**在class类中作为其成员的访问控制说明符**。

**在class中默认使用private访问说明符，除非指定特定访问说明符**。离成员往上最近的即为该成员的访问说明符，如果没有访问说明符 则使用默认访问说明符private。

**在struct中所有成员默认使用public访问说明符，除非指定特定访问说明符**。离成员往上最近的即为该成员的访问说明符，如果没有访问说明符 则使用默认访问说明符public。

在class/struct中的成员如果为**public修饰，该成员可在其他任何作用域内被访问**到。**protected和private 在当前class范围外不可访问(继承体现中另当别论，见下章节)，除非友元**。

举例如下：

#include <iostream>
    using namespace std;
    
    class A
    {
        // 没有访问说明符，则使用默认访问说明符private
        void fun1(){
        	cout << "A:fun1()" << endl; 
    	};
        int m1;
        public:
        	fun2(){
        		cout << "A:fun2()" << endl; 
    		};
        	int m2;
        protected:
        	fun3(){
        		cout << "A:fun3()" << endl; 
    		};
        	int m3;
        private:
        	fun4(){
        		cout << "A:fun4()" << endl; 
    		};
        	int m4;
        	
    	// 友元函数，可为普通全局函数 也可为class成员函数 
        friend void friendFun1(); 
    };
    struct B
    {
        // 没有访问说明符，则使用默认访问说明符public
            void fun1(){
        	cout << "B:fun1()" << endl; 
    	};
        int m1;
        public:
        	fun2(){
        		cout << "B:fun2()" << endl; 
    		};
        	int m2;
        protected:
        	fun3(){
        		cout << "B:fun3()" << endl; 
    		};
        	int m3;
        private:
        	fun4(){
        		cout << "B:fun4()" << endl; 
    		};
        	int m4;
    }; 
    
    // 友元函数，都成为某个class的朋友了，当然无话不谈了，class类中的所有成员亦可访问。 
    void friendFun1()
    {
    	cout << "===friendFun1 begin===" << endl;
    	A a; 
    	a.fun1(); // ok
    	a.fun2(); // ok
    	a.fun3(); // ok
    	a.fun4(); // ok
    	cout << "===friendFun1 end===" << endl;
    }
    
    int main(int argc,char* argv[])
    {
    	A a;
    //	a.fun1(); // 编译error
    	a.fun2(); // ok	,class之外的作用域可访问public成员， 
    //	a.fun3(); // 编译error
    //	a.fun4(); // 编译error
    	 
    	friendFun1();	// ok, class的友元函数 所有成员亦可访问。 
    	 
    	return 0;
    }

## 在继承体系中 ##

这里直接说结论了。

*  **class省略继承访问说明符，默认为private私有继承**
 *  **struct省略继承访问说明符，默认为public公有继承**
 *  **public公开继承：基类的所有公开成员可作为派生类的公开成员访问，基类的所有受保护成员可作为派生类的受保护成员访问（基类的私有成员始终不可访问，除非设为友元）。**
 *  **protected受保护继承：基类的所有公开和受保护成员可作为派生类的受保护成员访问（基类的私有成员始终不可访问，除非设为友元）**
 *  **private私有继承：基类的所有公开和受保护成员可作为派生类的私有成员访问（基类的私有成员始终不可访问，除非设为友元）**

举例如下：

#include <iostream>
    using namespace std;
    
    class Base
    {
    	public:
    	    void fun1(){
    	    	cout << "Base:fun1()" << endl; 
    		};
    	    int m1;
        protected:
        	fun2(){
        		cout << "Base:fun2()" << endl; 
    		};
        	int m2;
        private:
        	fun3(){
        		cout << "Base:fun3()" << endl; 
    		};
        	int m3;
    };
    
    // class省略继承访问说明符，默认为private继承 
    class A:Base
    {
       	public:
    		void Fun1(){
    			cout << "A:Fun1()" << endl; 
    		} 
    	protected:
    		void Fun2(){
    			cout << "A:Fun2()" << endl; 
    		}	
    	private:
    		void Fun3(){
    			cout << "A:Fun3()" << endl; 
    		} 	
    };
    // struct省略继承访问说明符，默认为public继承 
    struct B:Base
    {
       	public:
    		void Fun1(){
    			cout << "B:Fun1()" << endl; 
    		} 
    	protected:
    		void Fun2(){
    			cout << "B:Fun2()" << endl; 
    		}	
    	private:
    		void Fun3(){
    			cout << "B:Fun3()" << endl; 
    		} 
    };
    
    /*
    public公开继承
    基类的所有公开成员可作为派生类的公开成员访问，
    基类的所有受保护成员可作为派生类的受保护成员访问
    （基类的私有成员始终不可访问，除非设为友元） 
    */
    class C:public Base 
    {
        public:
    		void Fun1(){
    			cout << "C:Fun1()" << endl; 
    		} 
    	protected:
    		void Fun2(){
    			cout << "C:Fun2()" << endl; 
    		}	
    	private:
    		void Fun3(){
    			cout << "C:Fun3()" << endl; 
    		} 
    }; 
    
    /*
    protected保护继承
    基类的所有公开和受保护成员可作为派生类的受保护成员访问
    （基类的私有成员始终不可访问，除非设为友元）
    */ 
    class D:protected Base 
    {
        public:
    		void Fun1(){
    			cout << "D:Fun1()" << endl; 
    		} 
    	protected:
    		void Fun2(){
    			cout << "D:Fun2()" << endl; 
    		}	
    	private:
    		void Fun3(){
    			cout << "D:Fun3()" << endl; 
    		} 
    }; 
    
    /*
    private私有继承
    基类的所有公开和受保护成员可作为派生类的私有成员访问
    （基类的私有成员始终不可访问，除非设为友元） 
    */ 
    class E:private Base 
    {
        public:
    		void Fun1(){
    			cout << "E:Fun1()" << endl; 
    		} 
    	protected:
    		void Fun2(){
    			cout << "E:Fun2()" << endl; 
    		}	
    	private:
    		void Fun3(){
    			cout << "E:Fun3()" << endl; 
    		}    
    }; 
    	
    int main(int argc,char* argv[])
    {	
    	// B和C都是 public公有继承，其父类公有成员将成为子类公有成员，父类受保护成员也将成为子类受保护成员 
    	B b; 
    	C c; 
    	b.fun1(); // ok
    	c.fun1(); // ok
    	// A和E都是 private私有继承，其父类的 公有成员和 受保护成员, 都将成为子类的 私有成员
    	A a;
    	E e;
    //	a.fun1(); // 编译error
    //	e.fun1(); // 编译error
    	// D 为protected受保护继承， 其父类的 受保护成员将成为 子类受保护成员 
    	D d;
    //	d.fun1(); // 编译error	 
    	return 0;
    }