当前位置：首页 > news >正文

c++的几种构造函数

news 2025/7/7 0:20:37

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); // 拷贝构造函数创建 p2Person p3=p1;//!!!这样也会调用拷贝构造函数，这是全新的对象 和java不一样cout << p2.name << ", " << p2.age << endl; // 输出：Alice, 30return 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;
}