C++ 4种构造函数被调用时机

拷贝、赋值、容器中

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;


class A
{
public:
    A()
    {
        cout << "construct a" << endl;
    };
    A& operator=(const A &a)
    {
        cout << "assign function" << endl;
    }
    A(const A& a)
    {
        cout << "copy construct" << endl;
    }


    ~A()
    {
        cout << "destruct a" << endl;
    }
};

void func(A a)
{
    cout << "func a" << endl;
}

int main()
{
    vector<A> vec_1;
    vector<A> vec_2;
//    map<int, A> map_1;
    A a;//construct
//    cout << "-------------------" << endl;
//    vec_1.push_back(a);//copy construct
    vec_2.push_back(a);//copy construct
//    swap(vec_1, vec_2);//没有产生copy或construct

/*    
construct a
copy construct
copy construct
destruct a
destruct a
assign construct
*/
//    map_1[0] = a;

//    func(a);//copy construct
//    cout << "-------------------" << endl;

//    A a1 = a;//copy construct 
//    A a1;

//    a1 = a;//assign,总的来说会少调用一个析构,a1的析构掉了,赋值操作可以看成非构造函数，因为他本身是不构造新的对象的，对象本身已经存在

//    swap(a1, a);//copy construct assign construct assign construct destruct a

}
//容器析构的时候会调用每一个成员的析构函数
//使用容器的时候要特别注意类的构造、拷贝构造，析构，赋值函数

继承中

#include <iostream>

using std::cout;
using std::endl;

class Base
{
public:
    Base()
    {   
        cout << "No param" << endl;    
    }   
    Base(int a)
    {   
        cout << "with param" << endl;    
    }   
private://将COPY函数声明为Private可以防止COPY操作存在
    Base(const Base &b) 
    {   
        cout << "copy" << endl;
    }   
};

class Derived:public Base
{
public:
    Derived()//默认调用无参数的基类构造函数
    {   
    }   
    Derived(int a):Base(a)
    {}  
};



int main()
{
    Derived a;
    Derived b(2);
//    Derived c = a;
    cout << "main" << endl;
    return 0;
}

操作符重载

#include <iostream>
#include <string>

using namespace std;

//
class Book
{
private:
    unsigned int mId;
    string mName;
public:
    Book(unsigned int id, string name);
    Book(const Book &book);
    Book &operator=(const Book &book);
    ostream &operator<<(ostream &os);//重载为成员的话，左操作数必须是该类的object
    friend ostream &operator<<(ostream &os, Book &book);//nomember function
    Book operator+(Book &book);//成员函数方式实现的+
    friend Book operator-(Book &book1, Book &book2);
};

Book::Book(unsigned int id, string name)
{
    mId = id; 
    mName = name;
    cout << "construct" << endl;
}

Book::Book(const Book &book)
{
    mId = book.mId;
    mName = book.mName;
    cout << "copy construct" << endl;
}

Book &Book::operator=(const Book &book)
{
    mId = book.mId;
    mName = book.mName;
    cout << "assign construct" << endl;
    return *this;
}


ostream &Book::operator<<(ostream &os)
{
    os << "id:" << this->mId << endl;
    os << "name:" << this->mName << endl;
    return os; 
}

ostream &operator<<(ostream &os, Book &book)
{
    os << "id:" << book.mId << endl;
    os << "name:" << book.mName << endl;
    return os;
}


Book Book::operator+(Book &book)
{
    Book tmp(0,"");
    tmp.mId = 0;
    tmp.mName = this->mName + book.mName;
    return tmp;
}

Book operator-(Book &book1, Book &book2)
{
    Book tmp(0,"");
    tmp.mName = book1.mName + "-" + book2.mName;
    return tmp;
}

int main()
{
    Book hualuo(1, "hua luo zhi duo shao");
    Book zhiduoshao(2, "zhi duo shao");

    Book hualuo_copy = hualuo;//copy
    hualuo_copy = hualuo;//assign
    hualuo_copy << cout;
    cout << hualuo << endl;


    Book total = hualuo + zhiduoshao;
    cout << total << endl;

    Book minu = hualuo - zhiduoshao;
    cout << minu << endl;

    return 0;
}