c++ class的protected和private

protected函数，只能被子类内部和本类内部调用
private函数，只能被本类内部中调用

#include <iostream>

class base{
protected:
    int add(int x, int y){
        return x + y;
    }

public:
    int new_fun(int x, int y){
        return add(x, y);   // protected(private)属性的函数只能在类内部使用
    }
};

class derive: public base{
public:
    int derive_fun(int x, int y){
        return add(x, y);   // 继承于base，所以它可以访问父类base的protected属性的add函数
    }
};

int main(){
    base b;
    b.new_fun(1, 2);
    derive d;
    d.derive_fun(1, 2);
    return 0;
}

不希望定义的类(base)可以生成对象，而是要让子类derive来继承base后，子类可以生成对象。可以将base的构造函数/析构函数声明为protected，子类derive的构造函数/析构函数声明为public。

#include <iostream>
#include <stdio.h>

class base{
protected:
    base(){
        printf("base init\n");
    }
    ~base(){
        printf("base free\n");
    }

public:
    // 如果不用static，该函数是无法被调用的,只能使用类中的base_fun这个函数。其他成员无法操作到
    static void base_fun(){
        base a;
    }
    // 获取类内部生成的对象的地址，就可以通过地址访问其他成员
    static base* base_fun2(){
        static base c;
        return &c;
    }
    void base_fun3(){
        printf("hello world!\n");
    }
};

class derive: public base{
public:
    derive(){
        printf("derive init\n");
    }
    ~derive(){
        printf("derive free\n");
    }
};

int main(){
    base::base_fun();
    derive d;

    base *p_base = NULL;
    p_base = base::base_fun2();
    p_base->base_fun3();

    return 0;
}

返回的地址一定不能是在栈上面的，因为一旦base_fun()函数退出，该堆栈信息就会消失，所以base_fun()函数内部的生成对象放在静态区

编译器在为类对象分配栈空间时，会先检查类的析构函数的访问性，不仅是析构函数，只要是非静态的函数，编译器都会进行检查。如果类的析构函数是私有的，则编译器不会在栈空间上为类对象分配内存。