12. 访问限制public/private/protected

public: 任何人都可以访问

private: 类的成员函数可以访问这些成员变量或成员函数

protected: 类自己和子子孙孙可以访问

friends: 声明别人是你的朋友，别人就可以访问自己的private东西

#include "stdafx.h"
#include <iostream>
using namespace std;

class A
{
private:
    int i;
    int *p;
public:
    A()
    {
        p = 0; //指针一定需要初始化
        cout << "A::A()" << endl;
    }
    ~A()
    {
        if(p)
        delete p;
        cout << "A::~A(), i = " << i << endl;
    }
public:
    void set(int i)
    {
        this->i = i;
    }
    void f() { p = new int; }
    void g(A* q) { cout << q->i << endl; }
};

//new了之后，程序不delete，程序没问题.
//原因：现在的操作系统都是多进程操作系统，程序每一次运行时新的进程，这个程序起来，操作系统分配空间，4G蓄奴空间。进程结束空间就会回收.
//但是程序一直要跑的，eg:手机的程序。内存泄漏
int main()
{
    A* p = new  A[10]; //先申请内存，然后调用构造函数
                       //A::A()10次
    for (int i = 0; i < 10; i++)
    {
        p[i].set(i);
    }

    A b;
    b.set(100);
    p[0].g(&b); //100

    delete[] p; //先调用构造函数，调用10次，并且顺序是颠倒的
                //A::~A(), i = 9
                //A::~A(), i = 8
                //A::~A(), i = 7
                //A::~A(), i = 6
                //A::~A(), i = 5
                //A::~A(), i = 4
                //A::~A(), i = 3
                //A::~A(), i = 2
                //A::~A(), i = 1
                //A::~A(), i = 0       
    return 0;
}
//以上结果说明, private是对类来说的，不是针对对象的. 
//private的限制仅仅在编译时刻,运行时刻是不知道的.
//C++的OOP特性只在源代码级别存在，编译后的.o与其他语言一样,编译后已经丧失了OOP特性. 

struct X; //前向声明: X是个东西, 让void f(X*)运行通过
struct Y //放在前面原因:friend void Y::f(*X);
{
  void f(X*); //如果没有struct X,编译器不知道X是什么 安抚编译器
};

struct X
{
  private:
    int i;
   public:
    void initialize();
    friend void g(X*,int); //g函数可以访问私有成员变量i
    friend void Y::f(*X); //Y类中的f函数可以访问私有成员变量i
    friend struct Z; //Z类的所有成员函数都可以访问私有变量i
    friend void h(); //h函数可以访问私有成员变量i
};

void X::initialize()
{
  i = 0;
}

void g(X* x,int i)
{
  x->i = i;
}

void Y::f(X* x)
{
  x->i = 47;
}

class vs struct

class default to private.
struct default to public.