C++篇 String实现避坑指南：搞定构造，拷贝与析构，增删查改，流提取流插入与比对大小 一文全解

胖咕噜的稞达鸭2025-09-28 13:48

🎬 胖咕噜的稞达鸭 ：个人主页
🔥 个人专栏 : 《数据结构》《C++初阶高阶》

⛺️技术的杠杆，撬动整个世界!

复制代码

文章开始之前，string官方文档供大家参考。string官方文档

注意！！！本文注释是重点！！！

string的常用接口说明

  1. string类对象的常见构造
函数名称 用途
string() 构造空的string类对象，即空字符串
string(const char s) 用C-string来构造string类对象
string(size_t n, char c) string类对象中包含n个字符c
string(const string&s) 拷贝构造函数
  1. string类对象的容量操作
函数名称 用途
size 返回字符串有效字符长度
length 返回字符串有效字符长度
capacity 返回空间总大小
empty 检测字符串释放为空串，是返回true，否则返回false
clear 清空有效字符
reserve 为字符串预留空间**
resize 将有效字符的个数该成n个，多出的空间用字符c填充
  1. string类对象的访问及遍历操作
函数名称 用途
operator[] 返回pos位置的字符，const string类对象调用
begin+ end **begin获取一个字符的迭代器 + end获取最后一个字符下一个位
置的迭代器**
rbegin + rend **begin获取一个字符的迭代器 + end获取最后一个字符下一个位
置的迭代器**
  1. string类对象的修改操作
函数名称 用途
push_back 在字符串后尾插字符c
append 在字符串后追加一个字符串
operator+= 在字符串后追加字符串str
c_str 返回C格式字符串
find+npos **从字符串pos位置开始往后找字符c，返回该字符在字符串中的
位置**
rfind **从字符串pos位置开始往前找字符c，返回该字符在字符串中的
位置**
substr 在str中从pos位置开始，截取n个字符，然后将其返回
  1. string类非成员函数
函数名称 用途
operator+ 尽量少用，因为传值返回，导致深拷贝效率低
operator>> 输入运算符重载
operator<< 输出运算符重载
getline 获取一行字符串

现在我们就从初始化，拷贝构造，string的增删查改等多个方面进行讲述。

在string.h和string.cpp中进行声明和定义分离。

初始化和拷贝构造，析构以及频繁调用的函数实现

//string.h注意看注释

cpp 复制代码 
#pragma once
#include<iostream>
#include<assert.h>

using namespace std;

namespace Byte
{
	class string
	{
	public:
		//string()
		//	:_str(new char[1] {'\0'})//_str初始化申请一个字符的空间，里面放/0，避免解引用报错，这里不是在库string里
		//	,_size(0)
		//	,_capacity(0)
		//{ }
		//string(const char* str)
		//{
		//	_size = strlen(str);
		//	_capacity = _size;//初始化,capacity不包含\0
		//	_str = new char[_capacity + 1];//在开空间的时候多开一个
		//	strcpy(_str, str);//然后把这块空间拷贝过来
		//}//这样写没有考虑到\0

		//短小频繁调用的函数可以直接定义到类里面，默认是inline
		string(const char* str="")//注意这里需要"",常量字符串后面都有一个\0，这里什么都没有也会加一个\0，所以传" "
		{
			_size = strlen(str);//计算str的长度并将其赋值给_size
			_capacity = _size;//初始化,capacity不包含\0
			_str = new char[_capacity + 1];//在开空间的时候多开一个
			strcpy(_str, str);//然后把这块空间拷贝过来。_str为目标地
		}
     //s2要拷贝s1,首先让s2指向空，给了缺省值，在初始化列表的时候
		//给随机值，也有可能是空，成员变量_str初始化指向nullptr，

		//显示提供拷贝构造//假如用s1拷贝s2  s2(s1)//这里的s就是s1
		string(const string& s)
		{
			_str = new char[s._capacity + 1];//还是多开一个空间用来存放\0
			strcpy(_str, s._str);//拷贝进去
			_size = s._size;
			_capacity = s._capacity;
		}

		void swap(string& s)
		{
			//这个是要调用算法库中的swap，局部域在交换swap的时候要先找swap,否则会认为参数不匹配
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
		}
		//s2要跟s1有一样大的空间，让tmp去初始化
		string(const string& s)
		{
			string tmp(s._str);//拷贝构造
			swap( tmp);
			
		}
		//s1假设有一串字符，用s._str去构造tmp,s就是s1，用s1._str去构造tmp，
		// s1假设有一串字符，tmp中也有一串字符，而tmp中构造出的对象就是s2中想要的
		//这里就要进行交换，调用swap,交换里面的指针，size,capacity,成员前
		//前面没有写的，默认都是this，this在调用这个swap，this就是s2，
		//swap(this(s2),tmp),这里 就很好的完成了深拷贝

		//出了作用域，tmp会不会被销毁，会的；但是tmp销毁的是空指针，因为s2和tmp进行了交换
		//这里也就更好说明了为什么要初始化为nullptr.简单说也就是让tmp去干活，然后通过交换的方式去拿取


		//s1赋值给s2,string的深拷贝
		string& operator=(const string& s)
		{
			//为了防止自己给自己赋值 
			if (this != &s)
			{
				//s就是s1，this就是s2。this之前是有空间的，所以把_str释放掉
				delete[]_str;
				_str = new char[s._capacity + 1];//空间要多开一个，让s2指向一块新的空间
				strcpy(_str, s._str);//拷贝它的值，把s1拷贝给s2
				_size = s._size;
				_capacity = s._capacity;
			}
			return *this;
		}

		//新的写法/////////////////////////////////////
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				string tmp(s._str);
				swap(tmp);
			}
			return *this;
		}
		string& operator=(string tmp)
		{
			swap(tmp);
			return *this;
		}
		////////////////////////////////////////////////
		//写析构
		~string()
		{
			delete[]_str;//释放掉_str
			_str = nullptr;//将其置为空nullptr
			_size = _capacity = 0;//空间和大小赋值为0
		}

		const char* c_str()const//用于遍历
		{
			return _str;
		}
		size_t size()const
		{
			return _size;
		}
		size_t capacity()const
		{
			return _capacity;
		}
		//operator[]返回pos位置的引用方便读和写
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		const char& operator[](size_t pos)const
		{
			assert(pos < _size);
			return _str[pos];
		}

		
	private:
		char* _str=nullptr;
		size_t _capacity;
		size_t _size;

	};
	//static void test_string1()//如果文件中有很多个test_string1，静态全局只在当前文件中进行
	//{
	//	string s1;
	//	string s2("hello world");
	//}
	void test_string1();
	
}

//string.cpp中

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1

#include"string.h"

namespace  Byte

{
	void test_string1()
	{
		string s1;
		string s2("hello world");
		cout << s1.c_str() << endl;
		cout << s2.c_str() << endl;
		//进行遍历
		for (size_t i = 0; i < s2.size(); i++)
		{
			s2[i] += 2;
		}
		
		cout << s2.c_str() << endl;
	}

// test.cpp中

cpp 复制代码 
//模拟实现
#include<string.h>
#include "string.h"
int main()
{
	Byte::test_string1();
	return 0;
}

单独实现一个范围for的遍历

用到迭代器：屏蔽了底层的实现细节，提供了统一的类似访问容器的方式，不需要关系容器底层的实现细节

所以这里需要迭代器进行函数的封装

//string.h

cpp 复制代码 
typedef char* iterator;//定义了一个iterator，属于string类域
typedef const char* const_iterator;//const指针迭代器

iterator begin()//实现第一个位置
{
	return _str;
}
iterator end()//实现最后一个位置
{
	return _str+_size;
}
const_iterator begin()const//实现第一个位置
{
	return _str;
}
const_iterator end()const//实现最后一个位置
{
	return _str+_size;
}

string.cpp

cpp 复制代码 
for (auto e : s2)//范围for底层就是替换成迭代器
{
	cout << e << " ";
}
cout << endl;

string::iterator it = s2.begin();//有一个类型itertor在类域里面
while (it != s2.end())
{

	cout << *it << " ";//需要访问数据就解引用
	++it;//到下一个位置++
}
cout << endl;
//迭代器是一种封装的体现，首先把数据和方法都放到类里面，可以让别人访问的放在共有
//iterator封装不管什么容器什么数据结构，都让它的第一个位置指向begin，最后一个位置的下一个位置指向end
//要访问数据就解引用，到下一个位置就++
//屏蔽了底层的实现细节，提供了统一的类似访问容器的方式，不需要关系容器底层的实现细节

string的增删查改实现：

//string.h中

cpp 复制代码 
void reserve(size_t n);//用于申请空间,预先申请容量为n的内存空间，为避免后续频繁扩容，提升效率
void push_back(char ch);//插入一个字符
void append(const char* str);//插入一个字符串
string& operator+=(char ch);//重载加运算符，实现"字符串+=单个字符"的操作
string& operator+=(const char* str);//字符串+=不可修改单个字符"

void insert(size_t pos, char ch);//在pos位置之前插入一个字符
void insert(size_t pos, const char* str);//在pos位置之前插入一个字符串


void erase(size_t pos, size_t len = npos);//从pos位置开始,删除len个字符；若len默认值npos，则删除从pos到字符串末尾的所有字符

声明和定义分离，较长而且不会频繁调用的放在string.cpp中

//string.cpp

cpp 复制代码 
void string::reserve(size_t n)
{
	if (n > _capacity)
	{
		//实现手动扩容
		char* tmp = new char[_capacity + 1];
		strcpy(_str, tmp);
		delete[]_str;//_str空间内本有数据，释放掉
		_str = tmp;//让_str指向tmp这块空间
		_capacity = n;
	}
}
void string::push_back(char ch)
{
	if (_capacity == _size)//如果空间刚好满了
	{
		reserve(_capacity == 0 ? 4 : 2 * _capacity);//如果空间为空，就赋值给4个字节，扩容为4，空间不为空开始2倍扩容
	}
	_str[_size] = ch;
	_size++;
	_str[_size] = '\0';//在插入字符并且更新长度后，添加字符串结束符\0
}
void string::append(const char* str)//插入一个字符串
{
	size_t len = strlen(str);
	if (_size+len>_capacity)//如果字符串原本的长度加上要新加入的，总长度大于容量就需要扩容
	{
		reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
		//大于2倍的capacity就按照需要的长度开，不大于按照2倍扩容，还是避免频繁扩容
	}
	strcpy(_str + _size, _str);//_str+_size就是\0的位置
	_size += len;
}

string& string:: operator+=(char ch)//重载加运算符，实现"字符串+=单个字符"的操作
{
	push_back(ch);
	return *this;
}
string& string::operator+=(const char* str)//字符串+=不可修改单个字符"
{
	append(str);
	return *this;
}

void string::insert(size_t pos, char ch)//在pos位置之前插入一个字符
{
	assert(pos <= _size);//pos必须是_size内部的位置
	//考虑空间不够的情况
	if (_capacity == _size)
	{
		reserve(_capacity == 0 ? 4 : _capacity * 2);//为0赋值4，不为0按照2倍扩容
	}
	size_t end = _size+1;//往后挪一个位置
	while(end>pos)
	{
		_str[end] = _str[end - 1];
		--end;
	}
	_str[pos] = ch;//将pos的位置赋值ch
	++_size;
}
void string::insert(size_t pos, const char* str)//在pos位置之前插入一个字符串
{
	size_t len = strlen(str);
	assert(pos < _size);
	if (_size + len > _capacity)
	{
		reserve(_size + len > 2 * _capacity ? _size + len : _capacity * 2);
	}
	size_t end = _size + len;//end更新到_size+len的位置
	while (end >= pos + len)
	{
		_str[end] = _str[end - len];
		end --;
	}
	for(size_t i=0;i<len;i++)
	{
		_str[pos + i] = _str[i];
	}
	_size += len;
}

void string::erase(size_t pos, size_t len )//从pos位置开始,删除len个字符；若len默认值npos，则删除从pos到字符串末尾的所有字符
{
	assert(pos < _size);
	if (len > _size - pos)//_size=11,len=100
	{
		_str[pos] = '\0';//在pos的位置插入\0表示字符串终止
		_size = pos;
	}
	else
	{
		//_size=11,pos=3,len=2
		for (size_t i = pos + len; i <= _size; i++)
		{
			_str[i - len] = _str[i];
		}
		_size -= len;
	}
}

查找+字符比对

//string.cpp

cpp 复制代码 
size_t string::find( char ch, size_t pos )//从pos开始遍历，找到pos位置的数返回其下标,没找到返回npos
{
	for (size_t i = pos; i < _size; i++)
	{
		if (_str[i] = ch)
		{
			return i;
		}
	}
	return npos;
}
size_t string::find(const char* str, size_t pos )//pos从0开始
{
	//暴力匹配；字符串匹配的BM算法；KMP
	assert(pos < _size);
	const char* ptr = strstr(_str + pos, str);//返回对应位置的指针，前者是原串，后者是子串
	if (ptr == nullptr)
	{
		return npos;//如果没有匹配上返回npos
	}
	else
	{
		return ptr - _str;//假设匹配上了，两个指针相减就是它的下标
	}
}

string string:: substr(size_t pos , size_t len)//从pos位置开始取len个字符,然后构造一个字串
{
	assert(pos < _size);
	//如果len大于剩余字符的长度，更新一下len//11个字符要从\0后面取100个字符
	if (len > _size - pos)
	{
		len = _size - pos;
	}

	string sub;//返回子串
	sub.reserve(len);
	for (size_t i = 0; i < len; i++)
	{
		sub += _str[pos + i];//从pos位置开始的len个字符加等到sub中
	}

	return sub;//sub是一个局部对象，传值拷贝这里要调用拷贝构造，但是编译器有可能会优化
	//首先用sub拷贝一个临时对象，临时对象作为返回值，再去拷贝suffix对象，但是编译器优化
	//会将中间的临时对象优化掉，这里没有写拷贝构造，默认是浅拷贝
	//出了作用域，sub会自动销毁，销毁之后会将这临时对象也带走，所以suffix指向的就是一个野指针！！！
}


bool operator>(const string& s1, const string& s2)
{
	return strcmp(s1.c_str(), s2.c_str()) > 0;//strcmp小于0大于0等于0会返回
}
bool operator<=(const string& s1, const string& s2)
{
	return !(s1 > s2);
}
bool operator>=(const string& s1, const string& s2)
{
	return s1 > s2 || s1 == s2;
}
bool operator==(const string& s1, const string& s2)
{
	return  strcmp(s1.c_str(), s2.c_str()) == 0;//strcmp小于0大于0等于0会返回
	
}
bool operator!=(const string& s1, const string& s2)
{
	return !(s1 == s2);
}

//流插入流提取
ostream& operator<<(ostream& out, const string& s)//可以支持内置类型
{
	for (auto ch : s)
	{
		out << ch;//把每一块字符都取出来插入，遍历string
	}
	return out;
}
istream& operator>>(istream& in, string& s)//不需要访问私有，就没必要写成友元函数，但是必须是全局
{
	s.clear();
	s.reserve(1024);//插入的时候先扩容1024，防止插入字符的时候频繁扩容

	const int N = 254;
	char buff[N];
	int i = 0;

	char ch;
	//这样写不对in >> ch;流提取默认提取不到空格和换行的
	ch = in.get();//流提取只能gEt一个字符，
	while (ch != ' ' && ch != '\n')
	{
		buff[i++] = ch;//输入253个字符在buff里面
		if (i == N-1)
		{
			buff[i] = '\0';//最后一个方\0
			s += buff;
			i = 0;
		}

		//in >> ch;//加等之后获取另外一个字符
		ch = in.get();
	}
	if (i > 0)//里面还没有走完，但是遇到空格了
	{
		buff[i] = '\0';
		s += buff;
	}
	return in;//应该用空格符
}

//string.h

cpp 复制代码 
size_t find(char ch, size_t pos = 0);
size_t find(const char* str, size_t pos = 0);
string substr(size_t pos = 0, size_t len = npos);//从pos位置开始取len个字符,然后构造一个字串


bool operator<=(const string& s1, const string& s2);
bool operator>(const string& s1, const string& s2);
bool operator>=(const string& s1, const string& s2);
bool operator==(const string& s1, const string& s2);
bool operator!=(const string& s1, const string& s2);

//流插入流提取
ostream& operator<<(ostream& out, const string& s);
istream& operator>>( istream& in, string& s);

//test.cpp

cpp 复制代码 
void test_string4()
{
	string s("test.cpp.zip");
	size_t pos = s.find('.');
	string suffix = s.substr(pos);
	cout << suffix.c_str() << endl;
	//sub suffix每个字节都拷贝，同时指向一块空间，这里前面return sub的时候把这块空间就带走了
	//此时suffix的时候指向野指针，编译器把三个都优化了，中间都没有拷贝构造，所以这里一定要
	//进行深拷贝，所以一定要显示提供拷贝构造

	string copy(s);//这里还是浅拷贝
	cout << copy.c_str() << endl;

	s = suffix;//赋值
	cout << suffix.c_str() << endl;
	cout << s.c_str() << endl;

	
}

string模拟实现完整源码

相关推荐
天山老妖的混世牛魔王2 小时前
KMDF驱动编写遇到的第一个编译问题
c++·驱动开发
歪歪1002 小时前
如何根据实际需求选择使用 TCP 或 UDP 协议？
开发语言·网络·网络协议·tcp/ip·计算机网络·udp
不枯石2 小时前
Matlab通过GUI实现点云的导向(引导)滤波(附最简版)
开发语言·图像处理·算法·计算机视觉·matlab
熊猫_豆豆3 小时前
MATLAB 九大行星太阳系运行程序
开发语言·nginx·matlab
程序员三明治3 小时前
二分查找思路详解，包含二分算法的变种，针对不同题的做法
java·数据结构·算法·二分查找
枣伊吕波3 小时前
五十三、bean的管理-bean的获取、bean的作用域、第三方bean
java·开发语言
丁浩6663 小时前
Python---14.Python数据存储EXCEl和MySQL
开发语言·python
Tisfy3 小时前
MacOS - Clang使用bits/stdc++.h - 非官方(竞赛用) - 通用方法
开发语言·c++·macos
啦工作呢3 小时前
Sass：CSS 预处理器
开发语言·后端·rust
热门推荐
01GitHub 镜像站点02UV 工具安装与国内镜像源配置指南03UV安装并设置国内源04Spec-Kit 使用指南05阿里最新开源Wan2.2-Animate-14B 本地部署教程：统一双模态框架，MoE架构赋能电影级角色动画与替换06Burp与其他安全工具联动及代理设置教程07Multisim使用教程详尽版--(2025最新版)0846个Nano-banana 精选提示词，持续更新中09KGG转MP3工具|非KGM文件|解密音频10VsCode远程Copilot无法使用Claude Agent问题