C++ 类访问修饰符
关键字 public
、private
、 protected
称为访问修饰符
类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected来指定的
通过添加类访问修饰符,就可以实现数据封装
数据封装是面向对象编程的一个重要特点,它防止函数直接访问类类型的内部成员
C++ 类成员访问标记
C++ 中, 一个类可以有多个 public、protected 或 private 标记区域
每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的
成员和类的默认访问修饰符是 private
class Base { public: // 公有成员 protected: // 受保护成员 private: // 私有成员 };
公有 ( public ) 成员
公有 成员在程序中类的外部是可访问的
我们可以不使用任何成员函数来设置和获取公有变量的值
#include <iostream> using namespace std; class Line { public: double length; void setLength( double len ); double getLength( void ); }; // 成员函数定义 double Line::getLength(void) { return length ; } void Line::setLength( double len ) { length = len; } // 程序的主函数 int main( ) { Line line; // 设置长度 line.setLength(6.0); cout << "Length of line : " << line.getLength() <<endl; // 不使用成员函数设置长度 line.length = 10.0; // OK: 因为 length 是公有的 cout << "Length of line : " << line.length <<endl; return 0; }
编译和运行以上范例,输出结果如下:
Length of line : 6 Length of line : 10
私有 ( private ) 成员
私有 成员变量或函数在类的外部是不可访问的,甚至是不可查看的
只有类和友元函数可以访问私有成员
默认情况下,类的所有成员都是私有的
例如下面的范例中, width 是一个私有成员,这意味着,如果没有使用任何访问修饰符,类的成员将被假定为私有成员
class Box { double width; public: double length; void setWidth( double wid ); double getWidth( void ); };
实际开发中,为了更容易阅读,我们一般会在私有区域定义数据,在公有区域定义相关的函数,以便在类的外部也可以调用这些函数
#include <iostream> using namespace std; class Box { public: double length; void setWidth( double wid ); double getWidth( void ); private: double width; }; // 成员函数定义 double Box::getWidth(void) { return width ; } void Box::setWidth( double wid ) { width = wid; } // 程序的主函数 int main( ) { Box box; // 不使用成员函数设置长度 box.length = 10.0; // OK: 因为 length 是公有的 cout << "Length of box : " << box.length <<endl; // 不使用成员函数设置宽度 // box.width = 10.0; // Error: 因为 width 是私有的 box.setWidth(10.0); // 使用成员函数设置宽度 cout << "Width of box : " << box.getWidth() <<endl; return 0; }
编译和运行以上范例,输出结果如下:
Length of box : 10 Width of box : 10
保护 ( protected ) 成员
保护成员变量或函数与私有成员十分相似,但有一点不同,保护成员在派生类 ( 即子类 ) 中是可访问的
下面的代码与前面的范例类似,width 成员可被派生类 smallBox 的任何成员函数访问
#include <iostream> using namespace std; class Box { protected: double width; }; class SmallBox:Box // SmallBox 是派生类 { public: void setSmallWidth( double wid ); double getSmallWidth( void ); }; // 子类的成员函数 double SmallBox::getSmallWidth(void) { return width ; } void SmallBox::setSmallWidth( double wid ) { width = wid; } // 程序的主函数 int main( ) { SmallBox box; // 使用成员函数设置宽度 box.setSmallWidth(5.0); cout << "Width of box : "<< box.getSmallWidth() << endl; return 0; }
编译和运行以上范例,输出结果如下:
Width of box : 5
C++ 类访问修饰符在继承中的特点
有 public
, protected
, private
三种继承方式,它们相应地改变了基类成员的访问属性
-
public 继承
基类 public 成员,protected 成员,private 成员的访问属性在派生类中分别变成:public, protected, private
-
protected 继承
基类 public 成员,protected 成员,private 成员的访问属性在派生类中分别变成:protected, protected, private
-
private 继承
基类 public 成员,protected 成员,private 成员的访问属性在派生类中分别变成:private, private, private
但无论哪种继承方式,有两点都没有改变
private
成员只能被本类成员 ( 类内 ) 和友元访问,不能被派生类访问protected
成员可以被派生类访问
public 继承
#include<iostream> #include<assert.h> using namespace std; class A{ public: int a; A(){ a1 = 1; a2 = 2; a3 = 3; a = 4; } void fun(){ std::cout << a << std::endl; // 正确 std::cout << a1 << std::endl; // 正确 std::cout << a2 << std::std::endl; // 正确 std::cout << a3 << std::endl; // 正确 } public: int a1; protected: int a2; private: int a3; }; class B : public A{ public: int a; B(int i){ A(); a = i; } void fun(){ std::cout << a << endl; //正确,public 成员 std::cout << a1 << endl; //正确,基类的 public 成员,在派生类中仍是 public 成员 std::cout << a2 << endl; //正确,基类的protected成员,在派生类中仍是protected可以被派生类访问。 std::cout << a3 << endl; //错误,基类的private成员不能被派生类访问。 } }; int main(){ B b(10); cout << b.a << endl; cout << b.a1 << endl; //正确 cout << b.a2 << endl; //错误,类外不能访问protected成员 cout << b.a3 << endl; //错误,类外不能访问private成员 system("pause"); return 0; }
protected 继承
#include<iostream> #include<assert.h> using namespace std; class A{ public: int a; A(){ a1 = 1; a2 = 2; a3 = 3; a = 4; } void fun(){ cout << a << endl; //正确 cout << a1 << endl; //正确 cout << a2 << endl; //正确 cout << a3 << endl; //正确 } public: int a1; protected: int a2; private: int a3; }; class B : protected A{ public: int a; B(int i){ A(); a = i; } void fun(){ cout << a << endl; //正确,public成员。 cout << a1 << endl; //正确,基类的public成员,在派生类中变成了protected,可以被派生类访问。 cout << a2 << endl; //正确,基类的protected成员,在派生类中还是protected,可以被派生类访问。 cout << a3 << endl; //错误,基类的private成员不能被派生类访问。 } }; int main(){ B b(10); cout << b.a << endl; //正确。public成员 cout << b.a1 << endl; //错误,protected成员不能在类外访问。 cout << b.a2 << endl; //错误,protected成员不能在类外访问。 cout << b.a3 << endl; //错误,private成员不能在类外访问。 system("pause"); return 0; }
private 继承
#include<iostream> #include<assert.h> using namespace std; class A{ public: int a; A(){ a1 = 1; a2 = 2; a3 = 3; a = 4; } void fun(){ cout << a << endl; //正确 cout << a1 << endl; //正确 cout << a2 << endl; //正确 cout << a3 << endl; //正确 } public: int a1; protected: int a2; private: int a3; }; class B : private A{ public: int a; B(int i){ A(); a = i; } void fun(){ cout << a << endl; //正确,public 成员 cout << a1 << endl; //正确,基类public成员,在派生类中变成了 private,可以被派生类访问 cout << a2 << endl; //正确,基类的protected成员,在派生类中变成了 private,可以被派生类访问 cout << a3 << endl; //错误,基类的private成员不能被派生类访问 } }; int main(){ B b(10); cout << b.a << endl; // 正确。public 成员 cout << b.a1 << endl; // 错误,private 成员不能在类外访问 cout << b.a2 << endl; // 错误, private 成员不能在类外访问 cout << b.a3 << endl; // 错误,private 成员不能在类外访问 system("pause"); return 0; }