深拷贝与浅拷贝

首先来看一段代码

#include <iostream>
#include <string.h>
#include <assert.h>class String{public:String(const char* str = ""){assert(str != nullptr);_str = new char[strlen(str) + 1];strcpy(_str, str);}~String(){if(_str){delete[] _str;_str = nullptr;}}private:char* _str;
};int main(){String s1("hello, world!");String s2(s1);return 0;
}

这个简单的String类有没有问题呢？我们使用的是默认的拷贝构造函数，我们来运行一下。

浅拷贝

这是为什么呢？为什么new开辟的空间会被释放两次。

从上图，我们可以看出，使用s1拷贝构造s2就是将s1中的_str的值拷贝给了s2中的_str。导致s1._str与s2._str指向了同一块空间。因此在程序结束时，s1和s2分别调用各自的析构函数，所以同一块空间就被delete[]两次，这显然是不行的。
动态申请的空间是不能释放两次的，因为第一次释放，该空间就已经还给系统，再第二次释放之前，有可能该空间已经分配给其他用户，所以第二次释放有可能释放的是其他用户申请的空间，这显然是不合理的。
上述这种问题就是由于浅拷贝造成的。从上面的例子中，我们大概可以明白什么是浅拷贝。
浅拷贝就是将对象中的值拷贝过来，如果对象中管理了堆中的资源，最后会导致多个对象共享同一份资源。

深拷贝

如上图所示就是深拷贝。为每个对象独立分配资源，保证多个对象之间不会因为共享资源而导致资源被多次释放。

写时拷贝

写时拷贝就是一种拖延症，是在浅拷贝的基础上增加了引用计数的方式来实现的。写时拷贝在写的时候（即改变字符串的时候）才会真正开辟空间进行深拷贝，如果只是对数据的读，则只会进行浅拷贝。
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象是资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。

string类的模拟实现

string.h

#pragma once#include <iostream>
#include <assert.h>
#include <string.h>class String{friend std::ostream& operator<<(std::ostream& _cout, const String& s);friend std::istream& operator>>(std::istream& _cin, String& s);public:typedef char* iterator;typedef const char* const_iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}const_iterator begin() const{return _str;}const_iterator end() const{return _str + _size;}public:String(const char* str = ""): _str(nullptr), _capacity(0){assert(str != nullptr);_size = strlen(str);reserve(_size);strcpy(_str, str);}~String(){if(_str){delete[] _str;_str = nullptr;_size = 0;_capacity = 0;}}String(const String& s): _str(nullptr), _size(0), _capacity(0){String temp(s.c_str());swap(temp);}String& operator=(String s){swap(s);return *this;}public:void reserve(size_t capacity);void resize(size_t size, char ch = 0);public:String& operator+=(char ch);String& operator+=(const char* str);String operator+(char ch) const;String operator+(const char* str) const;char& operator[](size_t pos);const char& operator[](size_t pos) const;public:String& insert(size_t pos, char ch);String& insert(size_t pos, const char* str);String& push_back(char ch);String& append(const char* str);String& erase(size_t pos, size_t len = -1);size_t find(char ch, size_t pos = 0) const;size_t find(const char* str, size_t pos = 0) const;public:bool operator>(const String& s) const;bool operator==(const String& s) const;bool operator>=(const String& s) const;bool operator<(const String& s) const;bool operator<=(const String& s) const;bool operator!=(const String& s) const;public:size_t size() const{return _size;}size_t capacity() const{return _capacity;}char* c_str() const{return _str;}void swap(String& s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}private:char* _str;size_t _size;size_t _capacity;
};std::ostream& operator<<(std::ostream& _cout, const String& s);std::istream& operator>>(std::istream& _cin, String& s);

string.cpp

#include "string.h"void String::reserve(size_t capacity){if(capacity > _capacity || capacity == 0){if(capacity % 8 == 0){capacity += 8;}else{capacity = (capacity / 8 + 1) * 8;}char* temp = new char[capacity];if(_str){strcpy(temp, _str);}delete[] _str;_str = temp;_capacity = capacity - 1;}
}void String::resize(size_t size, char ch){if(size <= _size){_size = size;}else if(size <= _capacity){for(size_t i = _size; i < size; ++i){_str[i] = ch;}_size = size;}else{reserve(size);for(size_t i = _size; i < size; ++i){_str[i] = ch;}_size = size;}_str[_size] = '\0';
}String& String::insert(size_t pos, char ch){assert(pos <= _size);++_size;if(_size > _capacity){reserve(_capacity * 2);}for(int i = _size; i > (int)pos; --i){_str[i] = _str[i - 1];}_str[pos] = ch;return *this;
}String& String::insert(size_t pos, const char* str){assert(pos <= _size);int len = strlen(str);_size += len;if(_size > _capacity){reserve(_size);}for(int i = _size; i >= (int)pos + len; --i){_str[i] = _str[i - len];}strncpy(_str + pos, str, len);return *this;
}String& String::push_back(char ch){insert(_size, ch);return *this;
}String& String::append(const char* str){insert(_size, str);return *this;
}String& String::erase(size_t pos, size_t len){assert(pos < _size);if(len >= _size - pos - 1){_size = pos;_str[_size] = '\0';}else{for(int i = pos; i < (int)_size; ++i){_str[i] = _str[i + len];}}return *this;
}size_t String::find(char ch, size_t pos) const{for(int i = pos; i < (int)_size; ++i){if(_str[i] == ch){return i;}}return -1;
}size_t String::find(const char* str, size_t pos) const{char* temp = strstr(_str + pos, str);if(!temp){return -1;}return temp - _str;
}String& String::operator+=(char ch){insert(_size, ch);return *this;
}String& String::operator+=(const char* str){insert(_size, str);return *this;
}String String::operator+(char ch) const{String temp(*this);temp += ch;return temp;
}String String::operator+(const char* str) const{String temp(*this);temp += str;return temp;
}char& String::operator[](size_t pos){return *(_str + pos);
}const char& String::operator[](size_t pos) const{return *(_str + pos);
}bool String::operator>(const String& s) const{int ret = strcmp(_str, s._str);if(ret > 0){return true;}return false;
}bool String::operator==(const String& s) const{int ret = strcmp(_str, s._str);if(!ret){return true;}return false;
}bool String::operator>=(const String& s) const{return *this > s || *this == s;
}bool String::operator<(const String& s) const{return !(*this >= s);
}bool String::operator<=(const String& s) const{return !(*this > s);
}bool String::operator!=(const String& s) const{return !(*this == s);
}std::ostream& operator<<(std::ostream& _cout, const String& s){for(size_t i = 0; i < s.size(); ++i){_cout << s[i];}_cout << std::endl;return _cout;
}std::istream& operator>>(std::istream& _cin, String& s){if(s._str){delete[] s._str;s._str = nullptr;s._size = 0;s._capacity = 0;}char* temp = new char[2048];_cin >> temp;int len = strlen(temp);s.reserve(len);strcpy(s._str, temp);delete[] temp;temp = nullptr;s._size = len;return _cin;
}

『C++』string类模拟实现相关推荐

『TensorFlow』批处理类
『教程』Batch Normalization 层介绍基础知识下面有莫凡的对于批处理的解释: fc_mean,fc_var = tf.nn.moments(Wx_plus_b,axes=[0],# ...
『GoLang』string及其相关操作
1. 字符串简介双引号:字符串使用双引号括起来,其中的相关的转义字符将被替换 str := "Hello World! \n Hello Gopher! \n" 输出: Hell ...
『TensorFlow』专题汇总
TensorFlow函数查询『TensorFlow』0.x_&_1.x版本框架改动汇总『TensorFlow』函数查询列表_数值计算『TensorFlow』函数查询列表_张量属性调整『 ...
【C++篇】STL常见容器String的模拟实现
准备博主:大大怪先森(记得关注哦!) 编程环境:vs2013 所示代码:码源文章目录准备前言一.标准库中的tring类 1.了解类 2.string类的常见接口 2.1 string类对象的 ...
C++ string类（包括深浅拷贝）
目录一.字符码表一.为什么用string类二.使用标准库中的string类 1.string类 2.string中的常用接口说明 (1)string类对象的常见构造 (2)string类对象访问 ...
C++ STL : 模拟实现STL中的string类
string的文档介绍 string是表示字符序列的类标准的字符串类提供了对此类对象的支持,其接口类似于标准字符容器的接口,但添加了专门用于操作单字节字符字符串的设计特性. string类是使用c ...
『电子书』分享一波码农必备编程开发类书籍[转]
分享一些书籍看到书籍很多,感觉很不错,就收藏下来了,是百度盘的连接,失效的可以评论一下以此更新一下连接. 书籍清单 Python编程快速上手细说PHP(第2版) Python核心编程(第3版) L ...
内存分布malloc/calloc/realloc/free/new/delete、内存泄露、String模板、浅拷贝与深拷贝以及模拟string类的实现
内存分布一.C语言中的动态内存管理方式:malloc/calloc/realloc和free 1.malloc: 从堆上获得指定字节的内存空间,函数声明:void *malloc (int n); ...
String类的模拟实现
目录: 一.经典String类的问题 1,浅拷贝 2,深拷贝二.现代写法版的string类三.传统String类的模拟实现 1.迭代器 2.operator[] 3.size() 4.c_str( ...

『C++』string类模拟实现