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

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;
}