c++的对象之间的关系组合，继承，传参

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

/*
static数据成员
1.所有对象实现了信息共享
2.不属于某个具体的实例
3.static数据成员必须进行类外的二次定义性声明，不能在构造函数中初始化(冒号语法)
4.const static int m_i = 0;可以直接初始化
5.在函数中使用时，前面没有this
6.类名::static数据成员
*/
#if 0
class A
{
public:
    A(int i = 0,int j = 0) :m_i(i)
    {
        m_j = j;
    }
    void print()
    {//this
        cout << m_i << " " << m_j << endl;
    }
    /*
    在static成员函数中，不能直接用非static数据成员，因为此函数中没有this指针--需要显示的将要操作的对象传递
    可以直接访问static数据成员
    */
    static void show(A &t)
    {//static成员函数中，没有this指针
        cout << t.m_i << " " << m_j << endl;
    }
private:
//public:
    int m_i;
    static int m_j;
    const static int m_k = 5;
    //A s; //error
    static A t;
    A* p;
};
int A::m_j = 10;

void main()
{
    A a(2, 5);
    a.print();
    A::show(a);
    a.show(a);
    //A::m_i;  //error
    //A::m_j;
//    A::print(); //error
}
#endif

#if 0
class Node
{
public:
    Node(int v) :m_value(v), m_pnext(nullptr), m_prev(nullptr) {}
    static Node* _Next(Node* p)
    {
        return p->m_pnext;
    }
    static Node* _Prev(Node* p)
    {
        return p->m_prev;
    }
private:
    Node* m_pnext;
    Node* m_prev;
    int m_value;
};

void main()
{
    Node a(5);
    Node *p = Node::_Next(&a);
}
#endif

/*
依赖:一个类的对象作为另外一个类成员函数的参数
聚合：整体和部分，弱拥有， 公司和员工
组合：整体和部分，强拥有  电脑和cpu，鸟和翅膀---用...来实现  用..来构成
继承：is--a  
*/
#if 0
class Water
{
public:
    Water() {}
};
class Cat
{
public:
    void Live(Water w)
    {

    }
};
#endif
#if 0
class Book
{
};
class Computer
{
};
class Student
{
public:
    void Study(Book b, Computer c)
    {

    }
};
#endif

/*
设计一个不能在外部环境中创建该类对象的类
单例模式--创建一个对象
将构造函数定义成private或者protected
1.为了能定义对象，则定义一个静态的成员函数，在此函数中定义一个静态对象
  --如果返回值类型，则会调用拷贝构造
2.要求只创建一个对象，在将返回值改为&，此时没有创建对象，只是一个别名
3.
*/
#if 0
class Singleton
{
protected:
    Singleton() { cout << "Singleton" << endl; }
public:
    static Singleton& GetInstance()
    {
        static Singleton s;  //static对象只构造一次
        return s;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

};
void main()
{
    Singleton &s2 = Singleton::GetInstance();
    Singleton* p = (Singleton*)malloc(sizeof(Singleton));
    //*p = s2;
}
#endif

/*
* 封装，继承，多态
* 继承的三步骤：
* 1.除了构造和析构之外，全盘接收
* 2.改造
* 3.添加子类自己
*/
#if 0
class A
{
public:
    A() {}
    int m_i;
protected:
    int m_j;
private:
    int m_k;
};
class B :public A
{
public:
    void print() 
    {
        m_i = 10;
        m_j = 20;
        //m_k = 30; //error
    }
};
class C :protected A
{
public:
    void print()
    {
        m_i = 10;
        m_j = 20;
        //m_k = 30; //error
    }
};
class D :private A
{
public:
    void print()
    {
        m_i = 10;
        m_j = 20;
        //m_k = 30; //error
    }
};
class CC :public C  //
{//C类来说，m_i变成了protected，m_j还是protected,m_k不可访问
public:
    void print()
    {
        m_i = 1;
        m_j = 2;
        //m_k = 4;
    }
};
class DD :public D
{
    //D类说，m_i和m_j变成了private，m_k还是不可访问
public:
    void print()
    {
    //    m_i = 1;
    //    m_j = 2;
    //    m_k = 3;
    }
};
void main()
{
    cout << sizeof(B) << endl;
    cout << sizeof(C) << endl;
    cout << sizeof(D) << endl;
    cout << sizeof(CC) << endl;
    cout << sizeof(DD) << endl;
    B b;
    b.m_i = 10;
    //b.m_j = 20;
    //b.m_k = 30;
    C c;
    //父类的public属性被protected化，所以在外界访问不了m_i
    //c.m_i = 10;  //error
    //c.m_j = 20;  //er
    //c.m_k = 40;  //er
    D d;
    //父类的public属性和protected被private化，所以在外界访问不了m_i,m_j
    //d.m_i = 1;
    //d.m_j = 2;
    //d.m_k = 4;
}

/*
*               public            protected              private 
 public         public            protected              private

 protected      protected         protected              private

 private        不可访问          不可访问               不可访问
*/  

#endif

/*
构造子类对象--先调用基类的构造函数(给继承下来的基类中的数据成员初始化)
              再调用子类的构造函数(给子类自己新添加的数据成员初始化)
*/
class A
{
public:
    A() { cout << "A" << endl; }
    ~A() { cout << "~A" << endl; }
    void print() { cout << "A::print" << endl; }
private:
    int m_i;
};
class B :public A
{
public:
    B() { cout << "B" << endl; }
    ~B() { cout << "~B" << endl; }
/*    void print(int n)
    {
        cout << "B::print : n = " << n << endl;
    }*/
    void show()
    {
        cout << "show" << endl;
    }
private:
    int m_i;
    int m_j;
};
void main()
{
    B b;
    //b.print(10);
    //b.A::print();
    b.print();
    b.show();
    cout << sizeof(B) << endl;
}