类&对象详解（二）

二：类访问修饰符
1、数据封装是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 来指定的。关键字 public、private、protected 称为访问修饰符。
2、一个类可以有多个 public、protected 或 private 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的默认访问修饰符是 private。

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

公有成员（public）
公有成员在程序中类的外部是可访问的。可以不使用任何成员函数来设置和获取公有变量的值。
例：

#include <iostream>
using namespace std;

class A
{
	public:
	double length;
	void setlength(double len);
	double getlength(void);
};

//成员函数定义
double A::getlength(void)
{
	return length;
}
void A::setlength(double len)
{
	length = len;
}
int main()
{
	A a;
	//通过成员函数设置长度
	a.setlength(6.6);
	cout << "length =" << a.getlength() << endl;
	//通过成员变量设置长度
	a.length = 10.0;
	cout << "length =" << a.length << endl;
    return 0;
}

运行结果：

length =6.6
length =10

私有成员（private）
私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。(默认情况下，类的所有成员都是私有的即如果没有使用任何访问修饰符)
例：（width为私有成员）

class Box
{
   double width;
   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );
};

例：

#include <iostream>
 
using namespace std;
 
class A
{
   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );
 
   private:
      double width;
};
// 成员函数定义
double A::getWidth(void)
{
    return width ;
}
 
void A::setWidth( double wid )
{
    width = wid;
}
 
// 程序的主函数
int main( )
{
   A a;
   // 不使用成员函数设置长度
   a.length = 6.6; // OK: 因为 length 是公有的
   cout << "Length of box : " << a.length <<endl;
    // box.width = 10.0; // Error: 因为 width 是私有的
	
   // 使用成员函数设置宽度
   a.setWidth(8.8);  // 使用成员函数设置宽度
   cout << "Width of box : " << a.getWidth() <<endl;
 
   return 0;
}

运行结果：

Length of box : 6.6
Width of box : 8.8

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

#include <iostream>
using namespace std;
 
class A
{
   protected:
      double width;
};
 
class Ason:A // Ason 是派生类
{
   public:
      void setsonWidth( double wid );
      double getsonWidth( void );
};
// 子类的成员函数
double Ason::getsonWidth(void)
{
    return width ;
}
void Ason::setsonWidth( double wid )
{
    width = wid;
}
// 程序的主函数
int main( )
{
   Ason a;
 
   // 使用成员函数设置宽度
   a.setsonWidth(6.6);
   cout << "Width of a : "<< a.getsonWidth() << endl;
 
   return 0;
}

运行结果：

Width of a : 6.6

继承中的特点
有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<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 : 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成员
  return 0;
}

运行结果：

10
1

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

运行结果：

10

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

运行结果：

10

注：
如果继承时不显示声明是 private，protected，public 继承，则默认是 private 继承，在 struct 中默认 public 继承：
例：

class B : A {};
B b;
b.a;    //错误
b.a1;   //错误
b.a2;   //错误
b.a3;   //错误

来源于网路