阅读量:0
目录
专栏：C++学习笔记
在C++中，std::string是一个非常常用的类，它封装了对C风格字符串的处理。但是，在某些情况下，我们可能需要自己实现一个类似string的类来展示对C++核心概念的掌握。本文将深入剖析一个自定义的String类的实现，特别关注其构造、拷贝构造、赋值运算符重载以及析构函数的实现。
1. 经典的String类问题
以下是一个初步的String类实现：
#include <iostream> #include <cstring> #include <cassert> class String { public: // 构造函数，默认参数为空字符串 String(const char* str = "") { if (nullptr == str) { assert(false); // 断言检查 return; } _str = new char[strlen(str) + 1]; // 分配内存 strcpy(_str, str); // 拷贝字符串 } // 析构函数 ~String() { if (_str) { delete[] _str; // 释放内存 _str = nullptr; // 避免悬挂指针 } } private: char* _str; }; // 测试函数 void TestString() { String s1("hello bit!!!"); String s2(s1); // 默认拷贝构造 } int main() { TestString(); return 0; } 1.1 构造函数
- 功能：用于初始化对象。
- 操作：
- 检查输入指针是否为
nullptr。 - 分配足够的内存存储字符串。
- 拷贝字符串内容到新分配的内存中。
- 检查输入指针是否为
小李的理解
- 构造函数：就像你去商店买东西，店员先检查你要买的东西是否存在，然后给你打包好交给你。
1.2 析构函数
- 功能：用于释放对象占用的资源。
- 操作：
- 检查指针是否为空。
- 释放内存。
- 将指针置为
nullptr以避免悬挂指针。
小李的理解
- 析构函数：当你不需要某样东西时，店员会帮你处理掉它，并确保不会再使用它。
1.3 测试函数
- 功能：验证构造函数和析构函数的工作情况。
- 操作：
- 创建两个
String对象。 - 用默认的拷贝构造函数创建第二个对象。
- 创建两个
小李的理解
- 测试函数：就像试用新买的东西，确保它们都能正常工作。
1.4 需要记住的知识点
- 默认的拷贝构造函数执行的是浅拷贝（shallow copy）。
- 多个实例共享同一块内存，当其中一个实例被销毁时，其他实例会尝试访问已经释放的内存，导致程序崩溃。
2. 浅拷贝
浅拷贝是指编译器仅仅复制对象中的值（即指针地址），而不是指针所指向的内容。这意味着多个对象会共享同一份资源，如上例中的字符数组：
String s1("hello bit!!!"); String s2(s1); // 浅拷贝，s1和s2共享同一块内存 2.1 什么是浅拷贝
- 定义：浅拷贝只复制指针地址，多个对象共享同一份资源。
- 问题：当一个对象释放内存时，其他对象会访问无效内存，导致程序崩溃。
小李的理解
- 浅拷贝：就像两个孩子共用一个玩具，只有一个玩具，两人要共享。一个孩子用坏了，另一个孩子也不能用了。
2.2 需要记住的知识点
- 浅拷贝会导致多个对象共享同一块内存。
- 释放其中一个对象时，其他对象会尝试访问已释放的内存，导致程序崩溃。
3. 深拷贝
深拷贝则会创建对象时复制资源的内容，使每个对象拥有一份独立的资源。这需要显式定义拷贝构造函数和赋值运算符。以下是一个实现深拷贝的String类：
3.1 传统版写法的String类
#include <iostream> #include <cstring> #include <cassert> class String { public: // 构造函数 String(const char* str = "") { if (nullptr == str) { assert(false); // 断言检查 return; } _str = new char[strlen(str) + 1]; // 分配内存 strcpy(_str, str); // 拷贝字符串 } // 拷贝构造函数 String(const String& s) { _str = new char[strlen(s._str) + 1]; // 分配内存 strcpy(_str, s._str); // 拷贝字符串 } // 赋值运算符重载 String& operator=(const String& s) { if (this != &s) { // 自我赋值检查 char* pStr = new char[strlen(s._str) + 1]; // 分配新内存 strcpy(pStr, s._str); // 拷贝字符串 delete[] _str; // 释放旧内存 _str = pStr; // 更新指针 } return *this; } // 析构函数 ~String() { if (_str) { delete[] _str; // 释放内存 _str = nullptr; // 避免悬挂指针 } } private: char* _str; }; // 测试函数 void TestString() { String s1("hello bit!!!"); String s2(s1); // 使用拷贝构造函数 String s3 = s2; // 使用赋值运算符重载 } int main() { TestString(); return 0; } 3.1.1 拷贝构造函数
- 功能：创建新对象时分配新的内存，并拷贝字符串内容。
- 操作：
- 分配足够的内存存储字符串。
- 拷贝字符串内容到新分配的内存中。
小李的理解
- 拷贝构造函数：就像父母给每个孩子都买一份玩具，各自玩各自的，不会有冲突。
3.1.2 赋值运算符重载
- 功能：确保自我赋值时不会出错，并实现深拷贝。
- 操作：
- 检查自我赋值（如
s = s）。 - 分配新内存，拷贝字符串，释放旧内存，并更新指针。
- 检查自我赋值（如
小李的理解
- 赋值运算符重载：就像你决定换掉旧的玩具，先买个新的，再把旧的处理掉，确保整个过程不会出错。
3.1.3 需要记住的知识点
- 拷贝构造函数和赋值运算符必须显式定义以实现深拷贝。
- 深拷贝确保每个对象都有独立的资源，避免共享同一块内存。
4. 现代版写法的String类
现代C++中，可以利用临时对象和swap函数简化赋值运算符的实现：
#include <iostream> #include <cstring> #include <cassert> #include <algorithm> // 包含swap函数 class String { public: // 构造函数 String(const char* str = "") { if (nullptr == str) { assert(false); // 断言检查 return; } _str = new char[strlen(str) + 1]; // 分配内存 strcpy(_str, str); // 拷贝字符串 } // 拷贝构造函数 String(const String& s) : _str(nullptr) { String strTmp(s._str); // 创建临时对象 swap(_str, strTmp._str); // 交换内容 } // 赋值运算符重载 String& operator=(String s) { swap(_str, s._str); // 交换内容 return *this; } // 析构函数 ~String() { if (_str) { delete[] _str; // 释放内存 _str = nullptr; // 避免悬挂指针 } } private: char* _str; }; // 测试函数 void TestString() { String s1("hello bit!!!"); String s2(s1); // 使用拷贝构造函数 String s3 = s2; // 使用赋值运算符重载 } int main() { TestString(); return 0; } 4.1 拷贝构造函数
- 功能：利用临时对象实现深拷贝。
- 操作：
- 创建一个临时对象。
- 交换临时对象和当前对象的内容。
小李的理解
- 拷贝构造函数：就像把新玩具给孩子，然后把旧玩具处理掉，确保整个过程不会出错。
4.2 赋值运算符重载
- 功能：利用临时对象和
swap函数简化赋值运算符的实现。 - 操作：
- 利用临时对象进行深拷贝。
- 交换临时对象和当前对象的内容。
小李的理解
- 赋值运算符重载：就像在家里换家具时，先把新家具搬进来，再把旧家具搬走，确保整个过程不会出错。
4.3 需要记住的知识点
- 现代C++中，利用
swap和临时对象简化赋值运算符的实现，可以确保异常安全。- 这种方法使得代码简洁且高效。
5. 写时拷贝（了解）
写时拷贝（Copy-On-Write, COW）是一种优化技术，在实现浅拷贝的基础上增加引用计数。每次拷贝时增加引用计数，只有在实际写操作发生时才进行深拷贝：
#include <iostream> #include <cstring> #include <cassert> class String { public: // 构造函数 String(const char* str = "") { _str = new char[strlen(str) + 1]; strcpy(_str, str); _refCount = new int(1); // 引用计数 } // 拷贝构造函数 String(const String& s) : _str(s._str), _refCount(s._refCount) { ++(*_refCount); // 增加引用计数 } // 赋值运算符重载 String& operator=(const String& s) { if (this != &s) { if (--(*_refCount) == 0) { // 释放旧资源 delete[] _str; delete _refCount; } _str = s._str; _refCount = s._refCount; ++(*_refCount); // 增加引用计数 } return *this; } // 析构函数 ~String() { if (--(*_refCount) == 0) { // 释放资源 delete[] _str; delete _refCount; } } private: char* _str; int* _refCount; // 引用计数指针 }; // 测试函数 void TestString() { String s1("hello bit!!!"); String s2(s1); // 增加引用计数 String s3 = s2; // 增加引用计数 } int main() { TestString(); return 0; } 5.1 写时拷贝
- 定义：通过引用计数实现资源共享，仅在写操作时进行深拷贝。
- 操作：
- 每次拷贝时增加引用计数。
- 只有在实际写操作发生时才进行深拷贝。
小李的理解
- 写时拷贝：就像兄弟姐妹共享一个玩具，只有在其中一个想要修改玩具时，才会给他一个新的玩具。
5.2 需要记住的知识点
- 写时拷贝通过引用计数优化资源管理，减少不必要的深拷贝操作。
- 这种技术在某些情况下能提高性能，但也有复杂性增加和多线程不安全的问题。
6. 总结
实现一个自定义的String类，最重要的是理解和正确实现构造函数、拷贝构造函数、赋值运算符重载和析构函数。通过深拷贝和写时拷贝等技术，可以确保对象管理资源的正确性和高效性。
小李的理解
- 构造函数：初始化对象，确保资源正确分配。
- 析构函数：释放资源，避免内存泄漏。
- 拷贝构造函数：深拷贝确保每个对象有独立资源。
- 赋值运算符重载：自我赋值检查，深拷贝确保安全赋值。
- 现代C++：利用
swap和临时对象简化代码，实现异常安全。- 写时拷贝：优化资源管理，通过引用计数延迟深拷贝操作。
