C++ 里的访问控制

 

一、       类的域(scope)：

一个类的定义不仅定义了一个类型（type），而且还定义了域（scope）.类定义中声明的类型别名，声明的数据成员，声明或定义的成员函数都在该类的scope内。

简而言之,域即为类体。

 

二、类成员的访问方式：不管是在scope内还是在scope外访问

   通过类名+域操作符来使用类型别名；

   通过该类的对象或其引用或其指针来使用非静态成员；

   通过该类的对象或其引用或其指针或类名+域操作符来使用静态成员。

三、        Scope内外访问控制：

1.       scope内及友元内访问：

（1）       访问方式：遵循一般的类成员访问方式，只是经常省略掉this指针(实际上是通过this指针来访问本类当前对象的成员的)。

（2）       访问控制：完全无控制

注：友元函数包括两种：设为友元的全局函数，设为友元类中的成员函数。

 

2.       scope外访问：除scope内及友元之外的访问

（1）       访问方式：遵循一般的类成员访问方式。

（2）       访问控制：只能访问属于public标签的成员，而不能访问proteced或private的成员。

四、    private/public/protected访问权限控制：

        类中的private/public/protected访问权限控制的含义：一个函数（施事）对一个类的成员（包括成员变量及成员方法）的访问权限。

        具体说来：

        private成员只有该类自身的成员函数（即scope内）及其友元可以访问；

        protected成员只有该类的成员函数及其派生类的成员函数及友元函数可以访问；

        public成员则所有的函数都可以访问。

五、       类成员函数可以访问同类的其他对象的任何数据：

（1）       将类成员函数的一个形参设为同类型的其他对象的引用或指针；

（2）       在类成员函数体内通过该引用或指针直接访问其任何数据—因为此时属于scope内访问。

注：这说明同类的对象互相之间可以访问对方的任何数据。

 

例子：常见的例子如拷贝构造函数、赋值操作符，另外一例如下：

1 #include <iostream>
2 using namespace std;
3
4 class A{
5 public:
6      A(int i_,int j_)
7      {
8          i=i_;
9          j=j_;
10      }
11      void disp(A &a)
12      {
13          cout<<a.i<<endl<<a.j<<endl;
14      }
15
16 private:
17      int i;
18 protected:
19      int j;
20 };
21
22 int main(int argc, char* argv[])
23 {
24      A a(123,456);
25      A b(789,543);
26      a.disp(b);
27      b.disp(a);
28
29      return 0;
30 }

六、    类的继承：

1.  访问属性变化

使用private继承,父类的所有成员在子类中变为private;
使用protected继承,父类的protected和public成员在子类中变为protected, private成员不变;
使用public继承,父类中的成员属性不发生改变;

public:	protected:	private:
public继承	public	protected	---
protected继承	protected	protected	---
private继承	private	private	---

2.     成员继承：

可以认为派生类将基类的所有成员都继承过来了，派生类对象即包括基类的完整部分，又包括自己的派生部分。

a)         private成员也继承过来了，只是不能访问，即使在scope内或友元内也不行。

b)         静态成员也可以继承过来了（实际上派生类和基类共有的）.

c)         基类的构建函数和复制控制函数也继承过来了，只是不可以访问

d)         友元不可继承。

例子如下：

 

1 #include <iostream>
2 using namespace std;
3
4 class C{
5 public:
6      C(int val) : m_c(val) {}
7 private:
8     int m_c;
9 };
10
11 class D: public C{
12 public:
13      D(int val1, int val2) : C(val1), m_d(val2) {}
14     int m_d;
15 };
16
17 int main()
18 {
19
20
21      cout << sizeof(C) << " " << sizeof(D) << endl; // 4   8
22      D obj(2, 25);
23      cout << &obj << " " << &obj.m_d << endl; //0x0012FF78    0X0012FF7C
24     //cout << obj.m_c; //error, 不能访问
25
26      D *ptr = &obj;
27     int *iptr = (int *)ptr;
28      cout << *iptr << " " << *(iptr+1) << endl;//2   25
29     
30     return 0;
31 }
32
33