C++你不知道的事

class A {
public:
    A() { cout<<"A's constructor"<<endl; }
    virtual ~A() { cout<<"A's Destructor"<<endl; }
};

class B : public A {
public:
    B() { cout<<"B's constructor"<<endl; }
    virtual ~B() { cout<<"B's Destructor"<<endl; }

};

int main() {
    B b;
    return 0;
}

输出结果：
A’s constructor
B’s constructor
B’s Destructor
A’s Destructor
请按任意键继续…

构造顺序是先调用父类的构造函数，析构时先析构子类的，再析构父类的，理解成从外到内嵌套

#include <algorithm>
#include <iostream>
#include <map>
#include <vector>
#define IMIN numeric_limits<int>::min()
#define IMAX numeric_limits<int>::max()
#define FR(i,n) for(int i=0;i<n;i++)
#define CLC(x) memset(x,0,sizeof(x))
#define FILL(x,c) memset(x,c,sizeof(x))
using namespace std;
#include <iostream>
class A {
public:
    A() { foo(); }
    virtual ~A() { foo(); }
    virtual void foo() { std::cout << "1"; }
    void bar() { foo(); }
};

class B : public A {
public:
    virtual void foo() { std::cout << "2"; }
};

int main() {
    B b;
    b.bar();
    return 0;
}

输出结果：121
定义B b，首先调用父类构造函数，父类构造函数调用自己所在的
foo(),输出1，然后bar(),调用B的foo()，B的是默认析构函数，最后调用B的A的析构函数

不能利用函数参数const与否来重载，只能是返回类型不同或参数个数或参数类型不同

带你理解C++对象初始化的不同方式

#include<iostream>
using namespace std;
class MyClass
{
public:
int n;
public:
    MyClass(int i = 0) : n(i) {  cout <<"fir: "<< n<<endl;    }
    MyClass( MyClass &x) {  n = ++(x.n);  cout <<"sec:"<< n<<endl;   }
    MyClass &operator=( MyClass &x) { n = --x.n; cout <<"third:" <<n<<endl;
        return *this;}
    ~MyClass()    { cout << n; }
};
int main()
{
    MyClass obj1(1), obj2(2);//直接初始化
    MyClass obj3 = obj1;//复制初始化
    MyClass obj4 ;//直接初始化
    obj4 = obj2;//赋值运算符
    return 0;
}

输出：
fir: 1
fir: 2
sec:2
fir: 0
third:1
1212请按任意键继续…

来看看全局对象，静态对象，局部对象的析构顺序

#include <algorithm>
#include <iostream>
#include <map>
#include <vector>
#define IMIN numeric_limits<int>::min()
#define IMAX numeric_limits<int>::max()
#define FR(i,n) for(int i=0;i<n;i++)
#define CLC(x) memset(x,0,sizeof(x))
#define FILL(x,c) memset(x,c,sizeof(x))
using namespace std;
#include <iostream>
class A {
public:
    A() { cout<<"A's constructor"<<endl; }
    virtual ~A() { cout<<"A's Destructor"<<endl; }
};

class B{
public:
    B() { cout<<"B's constructor"<<endl; }
    virtual ~B() { cout<<"B's Destructor"<<endl; } 
};

class C{
public:
    C() { cout<<"C's constructor"<<endl; }
    virtual ~C() { cout<<"C's Destructor"<<endl; } 
};

class D{
public:
    D() { cout<<"D's constructor"<<endl; }
    virtual ~D() { cout<<"D's Destructor"<<endl; } 
};
class E{
public:
    E() { cout<<"E's constructor"<<endl; }
    virtual ~E() { cout<<"E's Destructor"<<endl; } 
};
C c;
E e;
int main() {
    A *pa = new A();
    B b;
    static D d;
    static E e;
    delete pa;
    return 0;
}

C’s constructor
E’s constructor
A’s constructor
B’s constructor
D’s constructor
E’s constructor

A’s Destructor
B’s Destructor
E’s Destructor
D’s Destructor
E’s Destructor
C’s Destructor
请按任意键继续…

请按任意键继续…

构造函数的调用顺序是根据实际运行定义的先后
析构函数：
a.一旦delete就马上调用析构函数
b.局部对象的析构优先>static >global（同级之间按声明顺序逆序）