目录
类的构造函数是类的一种特殊的成员函数,它会在每次创建类的新对象时执行,每次都会构造成员变量的初始化值,内存空间等。
构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回 void。构造函数可用于 为某些成员变量设置初始值
普通构造函数
#include <iostream>
#include <string>
using namespace std; // 使用std命名空间
class Car {
public:
string brand; // 不需要使用std::string
int year;
// 无参构造函数
Car() {
brand = "未知";
year = 0;
cout << "无参构造函数被调用" << endl; // 不需要使用std::cout和std::endl
}
void display() {
cout << "Brand: " << brand << ", Year: " << year << endl;
}
};
int main() {
Car myCar; // 创建Car对象
myCar.display(); // 显示车辆信息
return 0;
}
带参数构造函数
默认的构造函数没有任何参数,但如果需要,构造函数也可以带有参数。这样在创建对象时就会给对象 赋初始值,如下面的例子所示
#include <iostream>
#include <string>
using namespace std;
class Car {
public:
string brand;
int year;
// 带参数的构造函数,使用常规的赋值方式
Car(string b, int y) {
brand = b;
year = y;
}
void display() {
cout << "Brand: " << brand << ", Year: " << year << endl;
}
};
int main() {
Car myCar("Toyota", 2020); // 使用带参数的构造函数创建Car对象
myCar.display(); // 显示车辆信息
return 0;
}
拷贝构造函数
基本概念及发生条件
- 当一个新对象被创建为另一个同类型的现有对象的副本时:
- 例如: MyClass obj1 = obj2; 或 MyClass obj1(obj2); ,其中 obj2 是现有的对象
- 将对象作为参数传递给函数时(按值传递):
- 当对象作为参数传递给函数,并且参数不是引用时,会使用拷贝构造函数创建函数内部的对象 副本。
- 从函数返回对象时(按值返回):
- 当函数返回对象,并且没有使用引用或指针时,拷贝构造函数用于从函数返回值创建副本。
- 初始化数组或容器中的元素时:
- 例如,在创建一个包含对象的数组时,数组中的每个对象都是通过拷贝构造函数初始化的。
拷贝构造函数的典型声明如下:
class MyClass {
public:
MyClass(const MyClass& other);
};
其中, other 是对同类型对象的引用,通常是常量引用。
示例代码
#include <iostream>
#include <string>
using namespace std;
class Car {
public:
string brand;
int year;
// 常规构造函数
Car(string b, int y) : brand(b), year(y) {}
// 拷贝构造函数
Car(const Car& other) {
brand = other.brand;
year = other.year;
cout << "拷贝构造函数被调用" << endl;
}
void display() {
cout << "Brand: " << brand << ", Year: " << year << endl;
}
};
int main() {
Car car1("Toyota", 2020); // 使用常规构造函数
Car car2 = car1; // 使用拷贝构造函数
car1.display();
car2.display();
return 0;
}
浅拷贝
浅拷贝只复制对象的成员变量的值。如果成员变量是指针,则复制指针的值(即内存地址),而不是指 针所指向的实际数据。这会导致多个对象共享相同的内存地址。
#include <iostream>
using namespace std;
class Shallow {
public:
int* data;
Shallow(int d) {
//(d):这是初始化表达式。在这里,分配的 int 类型内存被初始化为 d 的值。如果 d 的值是
20,那么分配的内存将被初始化为 20。
data = new int(d); // 动态分配内存
cout << "观察数据:" << endl;
cout << d << endl;
cout << *data << endl;
cout << "观察内存在构造函数中:" << endl;
cout << data << endl;
}
// 默认的拷贝构造函数是浅拷贝
~Shallow() {
delete data; // 释放内存
}
};
int main() {
Shallow obj1(20);
Shallow obj2 = obj1; // 浅拷贝
cout << "观察内存在main函数obj2的data地址:" << endl;
cout << obj2.data << endl;
cout << "obj1 data: " << *obj1.data << ", obj2 data: " << *obj2.data << endl;
return 0;
}
在这个例子中, obj2 是通过浅拷贝 obj1 创建的。这意味着 obj1.data 和 obj2.data 指向相同的内 存地址。
当 obj1 和 obj2 被销毁时,同一内存地址会被尝试释放两次,导致潜在的运行时错误。
深拷贝
深拷贝复制对象的成员变量的值以及指针所指向的实际数据。这意味着创建新的独立副本,避免了共享 内存地址的问题。
#include <iostream>
using namespace std;
class Deep {
public:
int* data;
Deep(int d) {
data = new int(d); // 动态分配内存
cout << "观察数据:" << endl;
cout << d << endl;
cout << *data << endl;
cout << "观察内存在构造函数中:" << endl;
cout << data << endl;
}
// 显式定义深拷贝的拷贝构造函数
Deep(const Deep& source) {
data = new int(*source.data); // 复制数据,而不是地址
cout << "深拷贝构造函数\n";
}
~Deep() {
delete data; // 释放内存
}
};
int main() {
Deep obj1(20);
Deep obj2 = obj1; // 深拷贝
cout << "观察内存在main函数obj2的data地址:" << endl;
cout << obj2.data << endl;
cout << "obj1 data: " << *obj1.data << ", obj2 data: " << *obj2.data << endl;
return 0;
}
在这个例子中, obj2 是通过深拷贝 obj1 创建的。这意味着 obj1.data 和 obj2.data 指向不同的内 存地址。每个对象有自己的内存副本,因此不会相互影响,避免了潜在的运行时错误。
遵循规则三则
在 C++ 中,规则三则(Rule of Three)是一个面向对象编程原则,它涉及到类的拷贝控制。规则三则指 出,如果你需要显式地定义或重载类的任何一个拷贝控制操作(拷贝构造函数、拷贝赋值运算符、析构 函数),那么你几乎肯定需要显式地定义或重载所有三个。这是因为这三个功能通常都是用于管理动态 分配的资源,比如在堆上分配的内存。
遵循规则三则的简单示例:
#include <iostream>
#include <cstring>
class MyClass {
private:
char* buffer;
public:
// 构造函数
MyClass(const char* str) {
if (str) {
buffer = new char[strlen(str) + 1];
strcpy(buffer, str);
} else {
buffer = nullptr;
}
}
// 析构函数
~MyClass() {
delete[] buffer;
}
// 拷贝构造函数
MyClass(const MyClass& other) {
if (other.buffer) {
buffer = new char[strlen(other.buffer) + 1];
strcpy(buffer, other.buffer);
} else {
buffer = nullptr;
}
}
// 拷贝赋值运算符
MyClass& operator=(const MyClass& other) {
if (this != &other) {
delete[] buffer; // 首先删除当前对象的资源
if (other.buffer) {
buffer = new char[strlen(other.buffer) + 1];
strcpy(buffer, other.buffer);
} else {
buffer = nullptr;
}
}
return *this;
}
};
int main() {
MyClass obj1("Hello");
MyClass obj2 = obj1; // 调用拷贝构造函数
MyClass obj3("World");
obj3 = obj1; // 调用拷贝赋值运算符
return 0;
}
在这个例子中:
- 构造函数为成员变量 buffer 分配内存,并复制给定的字符串。
- 析构函数释放 buffer 所占用的内存,以避免内存泄露。
- 拷贝构造函数创建一个新对象作为另一个现有对象的副本,并为其分配新的内存,以避免多个对象 共享同一内存。
- 拷贝赋值运算符更新对象时,首先释放原有资源,然后根据新对象的状态分配新资源
这个类遵循规则三则,确保了动态分配资源的正确管理,避免了内存泄露和浅拷贝问题。
避免不必要的拷贝
避免不必要的拷贝是 C++ 程序设计中的一个重要原则,尤其是在处理大型对象或资源密集型对象时。使 用引用(包括常量引用)和移动语义(C++11 引入)是实现这一目标的两种常见方法。
使用引用传递对象
通过使用引用(尤其是常量引用)来传递对象,可以避免在函数调用时创建对象的副本。
#include <iostream>
#include <vector>
using namespace std;
class LargeObject {
// 假设这是一个占用大量内存的大型对象
};
void processLargeObject(const LargeObject& obj) {
// 处理对象,但不修改它
cout << "Processing object..." << endl;
}
int main() {
LargeObject myLargeObject;
processLargeObject(myLargeObject); // 通过引用传递,避免拷贝
return 0;
}
在这个例子中, processLargeObject 函数接受一个对 LargeObject 类型的常量引用,避免了在函数 调用时复制整个 LargeObject 。
使用移动语义
C++11 引入了移动语义,允许资源(如动态分配的内存)的所有权从一个对象转移到另一个对象,这避 免了不必要的拷贝。
#include <iostream>
#include <utility> // 对于 std::move
using namespace std;
class MovableObject {
public:
MovableObject() {
// 构造函数
}
MovableObject(const MovableObject& other) {
// 拷贝构造函数(可能很昂贵)
}
MovableObject(MovableObject&& other) noexcept {
// 移动构造函数(轻量级)
// 转移资源的所有权
}
MovableObject& operator=(MovableObject&& other) noexcept {
// 移动赋值运算符
// 转移资源的所有权
return *this;
}
};
MovableObject createObject() {
MovableObject obj;
return obj; // 返回时使用移动语义,而非拷贝
}
int main() {
MovableObject obj = createObject(); // 使用移动构造函数
return 0;
}
在这个例子中, MovableObject 类有一个移动构造函数和一个移动赋值运算符,它们允许对象的资源 (如动态分配的内存)在赋值或返回时被“移动”而非复制。这减少了对资源的不必要拷贝,提高了效率。
通过这些方法,你可以在 C++ 程序中有效地减少不必要的对象拷贝,尤其是对于大型或资源密集型的对 象。
拷贝构造函数的隐式调用
在 C++ 中,拷贝构造函数可能会在几种不明显的情况下被隐式调用。这种隐式调用通常发生在对象需要被复制时,但代码中并没有明显的赋值或构造函数调用。了解这些情况对于高效和正确地管理资源非常重要。
作为函数参数传递(按值传递)
当对象作为函数参数按值传递时,会调用拷贝构造函数来创建参数的本地副本。
#include <iostream>
using namespace std;
class MyClass {
public:
MyClass() {}
MyClass(const MyClass &) {
cout << "拷贝构造函数被隐式调用" << endl;
}
};
void function(MyClass obj) {
// 对 obj 的操作
}
int main() {
MyClass myObject;
function(myObject); // 调用 function 时,拷贝构造函数被隐式调用
return 0;
}
从函数返回对象(按值返回)
当函数返回一个对象时,拷贝构造函数会被用于创建返回值的副本。
MyClass function() {
MyClass tempObject;
return tempObject; // 返回时,拷贝构造函数被隐式调用
}
int main() {
MyClass myObject = function(); // 接收返回值时可能还会有一次拷贝(或移动)
return 0;
}
初始化另一个对象
当用一个对象初始化另一个同类型的新对象时,会使用拷贝构造函数
int main() {
MyClass obj1;
MyClass obj2 = obj1; // 初始化时,拷贝构造函数被隐式调用
return 0;
}
在所有这些情况下,如果类包含资源管理(例如,动态内存分配),那么正确地实现拷贝构造函数是非 常重要的,以确保资源的正确复制和管理,防止潜在的内存泄漏或其他问题。此外,随着 C++11 的引 入,移动语义提供了对资源的高效管理方式,可以减少这些场景中的资源复制。
禁用拷贝构造函数
禁用拷贝构造函数是一种常用的做法,尤其是在设计那些不应该被复制的类时。这可以通过将拷贝构造函数声明为 private 或使用 C++11 引入的 delete 关键字来实现。这样做的目的是防止类的对象被拷贝,从而避免可能导致的问题,如资源重复释放、无意义的资源复制等
使用 delete 关键字
可以使用 delete 关键字明确指定不允许拷贝构造
class NonCopyable {
public:
NonCopyable() = default; // 使用默认构造函数
// 禁用拷贝构造函数
NonCopyable(const NonCopyable&) = delete;
// 禁用拷贝赋值运算符
NonCopyable& operator=(const NonCopyable&) = delete;
};
int main() {
NonCopyable obj1;
// NonCopyable obj2 = obj1; // 编译错误,拷贝构造函数被禁用
return 0;
}
使用 private 声明
常见的做法是将拷贝构造函数和拷贝赋值运算符声明为 private ,并且不提供实现:
class NonCopyable {
private:
// 将拷贝构造函数和拷贝赋值运算符设为私有
NonCopyable(const NonCopyable&);
NonCopyable& operator=(const NonCopyable&);
public:
NonCopyable() {}
};
int main() {
NonCopyable obj1;
// NonCopyable obj2 = obj1; // 编译错误,因为无法访问私有的拷贝构造函数
return 0;
}
在这个例子中,任何尝试拷贝 NonCopyable 类型对象的操作都会导致编译错误,因为拷贝构造函数和拷贝赋值运算符是私有的,外部代码无法访问它们。 通过这些方法,你可以确保你的类的对象不会被意外地拷贝,从而避免可能出现的资源管理相关的错误。