03 访问限制

访问限制private

public、private 成员函数才能访问 、protected 只能子类去调用，子类的对象不能调用。

private是对类来说的 不是对对象的。同一个类的对象之间是可以互相访问的私有成员变量
仅仅在编译阶段进行限制。

#include<iostream>
using namespace std;
class A {
private:
    int i;
    int *p;
public:
    A() { p=0; cout << "A::A()" << endl; } // p 指针初始化 将其指向null
    ~A(){ if(p) delete p; cout << "A::~A() i = "<< i << endl;} 
    // 如果p不为空(经历f函数的调用 拥有new过程)，则delete p，
    // 如果没有new过程,p 指向null，则不会使用delete（前提是需要将指针初始化）。
    void set(int ii) { i = ii; }
    void f() {p = new int; }
    void g(A* q) { cout << "A::g(),q->i = " << q->i << endl; }
};
int main(){
    A *p = new A[10];
    for ( int i=0; i<10; i++ )
        p[i].set(i);
    A b;
    b.set(100);
	p[0].g(&b);// 将b的地址传递给p[0]， p[0]能访问到b的私有变量 
    delete[] p;
}

friend 也可以访问私有成员变量

在运算符重载用到比较多
friend 授权也是 在编译环节

friend 在运算符重载的时候用的比较多

struct X; // 前向声明

struct Y {
    void f(X*); // 必须用指针; 
    // 使用void f(X c); 是不行的(X和Y交叉关系错误, 无法使用X声明一个变量c。故只能使用指针)
};

struct X{
private:
    int i;
public:
    void initialized();
    // 下面语句说明 他们是X的朋友，所以他们可以访问X的私有变量
    friend void g(X*, int); //global friend
    friend void Y::f(X*); // Struct member friend
    friend struct Z; //Entire struct is a friend Z的函数都能访问私有变量 
    friend void h();
};

void X::initialized(){
    i = 0;
}
void g(X* x, int i){
    x->i = i;
}
void Y::f(X* x){
    x->i = 47;
}
struct Z{
private:
    int j;
}

class和struct的区别

• class defaults to private
• struct defaults to public

首选class 。过于简单的类就使用struct