类对象定义

C++类访问修饰符

数据封装是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 来指定的。关键字 public、private、protected 称为访问修饰符。

class Base {
        public:   // 公有成员    protected:   // 受保护成员    private:   // 私有成员 };复制代码

公共（public）成员

公有成员在程序中类的外部是可访问的。您可以不使用任何成员函数来设置和获取公有变量的值，如下所示：

#include 
    
      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() <

私有（private）成员

私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。

只有类和友元函数可以访问私有成员。

默认情况下，类的所有成员都是私有的。

#include 
    
      using namespace std; class Box{
        //double width; 不填写权限，默认是私有权限修饰符   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 <

保护（protected）成员

保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。

#include 
    
     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;}复制代码

继承中的特点

有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。

1.**public 继承：**基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private

2.**protected 继承：**基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：protected, protected, private

3.**private 继承：**基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：private, private, private

但无论哪种继承方式，上面两点都没有改变：

1.private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；

2.protected 成员可以被派生类访问。

public 继承

#include
    
     #include
     
      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 : public A{public:  int a;  B(int i){    A();    a = i;  }  void fun(){    cout << a << endl;       //正确，public成员    cout << a1 << endl;       //正确，基类的public成员，在派生类中仍是public成员。    cout << a2 << endl;       //正确，基类的protected成员，在派生类中仍是protected可以被派生类访问。    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
    
     #include
     
      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
    
     #include
     
      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;}复制代码