c++的几种构造函数

构造函数

C++中的构造函数可以分为5类：默认构造函数、普通构造函数、拷贝构造函数、转换构造函数、移动构造函数。

好像还有委托构造

默认构造和普通构造和java基本一样

详细

拷贝构造函数

拷贝构造函数用于从另一个已存在的对象创建新对象。 而不共享原始对象的数据。

class Person {
public:
  string name;
  int age;
 
  Person(const Person& other) { // 拷贝构造函数
    name = other.name;
    age = other.age;
  }
};
 
int main() {
  Person p1("Alice", 30); // 创建 Person 对象
  Person p2(p1); // 拷贝构造函数创建 p2

  Person p3=p1;//!!!这样也会调用拷贝构造函数，这是全新的对象 和java不一样
 
  cout << p2.name << ", " << p2.age << endl; // 输出：Alice, 30
 
  return 0;
}

如果你没有显式定义拷贝构造函数，编译器会自动生成一个默认拷贝构造函数。这个默认的拷贝构造函数会逐成员地对对象进行浅拷贝。

补充！！

Complex c2(c1);
Complex c2 = c1;
//这两条语句是等价的。复制构造函数的调用

Complex c1, c2;
c1=c2;
//第二条语句是初始化语句，不是赋值语句。不会调用复制构造函数，
//此时是对 c1 赋予新的值 c2，这会调用类的拷贝赋值运算符operator=()
//在 C++ 中，c1 = c2; 是深拷贝行为。c1 和 c2 是两个独立的对象。c1 = c2; 将 c2 的值拷贝到 c1，相当于复制了 c2 的内容。

还有补充！！！

class A{
public:
    A(){};
    A(A & a){
        cout<<"Copy constructor called"<<endl;
    }
};
void Func(A a){ }
int main(){
    A a;
    Func(a); //这里会调用A类的拷贝构造函数，
    return 0;
}

如果形参是一个对象，那么形参的值是否等于实参，取决于该对象所属的类的复制构造函数是如何实现的。如果复制构造函数随便写的，那传进去的就…

在函数被调用时，生成的形参要用复制构造函数初始化，这会带来时间上的开销。可以用将形参声明为对象的 const 引用代替

转换构造函数

一个构造函数接收一个不同于其类类型的形参，可以视为将其形参转换成类的一个对象。像这样的构造函数称为转换构造函数。在 C++ string 类中可以找到使用转换构造函数的实用示例。string 类提供一个将 C 字符串转换为 string 的转换构造函数

class string
{
    //仅显示转换构造函数
    public:
        string(char *);//形参时其他类型变量，且只有一个形参
};

移动构造函数

移动构造和move
建议这一篇我的笔记

下面这个例子是没有使用移动构造函数的，会有内存的浪费

// g++ 14_Copy_Date.cpp -std=c++11
#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

#define MAX_NEW_MEM		(64*1000*1000)

class CDate
{
public:
	CDate(int year, int mon, int day);	// 构造函数声明
	CDate(const CDate& date);			// 拷贝构造函数声明
	~CDate();							// 析构函数声明
	
	CDate operator+(int day);			// 加号运算符声明

	void show()
	{
		cout << "Date: " << m_year << "." << m_mon << "." << m_day << ", this=" << this << endl;
		//cout << "Date: " << str << endl;
	}

private:
	int m_year;
	int m_mon;
	int m_day;
	char *str;
};

// 构造函数定义
CDate::CDate(int year, int mon, int day)
{
	m_year = year;
	m_mon = mon;
	m_day = day;
	str = new char[MAX_NEW_MEM];
	sprintf(str, "%4d.%02d.%02d", year,mon,day);
	cout << "Calling Constructor" << ", this=" << this <<endl;
}

// 拷贝构造函数定义
CDate::CDate(const CDate& date)
{
	m_year = date.m_year;
	m_mon = date.m_mon;
	m_day = date.m_day;
	str = new char[MAX_NEW_MEM];
	memcpy(str, date.str, MAX_NEW_MEM);
	cout << "Calling Copy Constructor" << ", this=" << this << ", Copy Data" <<endl;
}

// 析构函数定义
CDate::~CDate()
{
	cout << "Calling Destructor" << ", this=" << this <<endl;
	delete [] str;
}

CDate CDate::operator+(int day)
{
	CDate temp = *this;
	temp.m_day += day;
	cout << "Calling operator+" << ", this=" << &temp << endl;
	return temp;
}

int main()
{
	CDate date(2024,06,07);
	cout << endl;
	CDate date1 = std::move(date+1);// std::move 强制将 date+1 的求值结果转为右值
    //std::move 强制将 date+1 的求值结果转为右值，避免编译器优化；
    //这里其实 std::move(date+1) 是temp
    //temp 对象赋值给date1之后，就销毁了，如果可以直接将temp对象的资源给到date1，就可以减少一次复制。
	date1.show();
	cout << endl;
	return 0;
}

参考

移动构造：

CDate(CDate &&date) noexcept;	// 声明
CDate::CDate(CDate&& date) noexcept // 实现 加上noexcept，用于通知标准库不抛出异常。提高性能
{
	m_year = date.m_year;
	m_mon = date.m_mon;
	m_day = date.m_day;
	str = date.str;
	date.str = NULL;
	cout << "Calling Move Constructor" << ", this=" << this <<endl;
}
int main()
{
	CDate date(2024,06,07);
	CDate date1 = std::move(date+1);// std::move 强制将 date+1 的求值结果转为右值
	date1.show();
	return 0;
}

运行结果：可以看到相比于第一小节的代码，这里调用了移动构造函数，减少了一次拷贝。

std::move

class B
{
public:
	B() {}
	B(const B&) { cout << "B Copy Constructor" << endl; }
};

class A {
private:
    B* pb;

public:
    // 默认构造函数
    A() {
        pb = new B();
        cout << "A Constructor" << endl;
    }

    // 拷贝构造函数（深拷贝）
    A(const A& src) {
        pb = new B(*(src.pb));
        cout << "A Copy Constructor" << endl;
    }

    // 移动构造函数
    A(A&& src) noexcept {
        pb = src.pb;
        src.pb = nullptr; // 防止 src 析构时释放原来的堆内存
        cout << "A Move Constructor" << endl;
    }
    // 析构函数
    ~A() {
        delete pb;
        cout << "A Destructor" << endl;
    }
};

static A getA()
{
	A a;
	cout << "================================================" << endl;
	return a;
}

int main()
{
	A a = getA();//A a = getA();调用的是A的移动构造，
	cout << "================================================" << endl;
	A a1(a);//A a1(a); 调用的是A的拷贝构造。A的拷贝构造需要对成员变量B进行深拷贝
    cout << "================================================" << endl;
	A a2(std::move(a));//A a2(std::move(a));将a转换为右值，因此a2调用的是移动构造而不是拷贝构造。
	system("pause");
	return 0;
}

析构函数

它会在每次删除所创建的对象时执行。

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀