2024年最全C++_String增删查改模拟实现(2)，海尔C C++面试总结

最新推荐文章于 2024-10-04 10:10:54 发布
最新推荐文章于 2024-10-04 10:10:54 发布
阅读量671 收藏 14
点赞数 28
分类专栏： 程序员 文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84978645/article/details/138815674
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

{
//扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
//插入数据
_str[_size] = ch;
_size++;
_str[_size] = ‘\0’;

}


### 5.2 append尾部插入字符串

void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)//扩容
{
reserve(_size + len);
}
strcpy(_str + _size, str);
_size += len;
}


### 5.3 operator+=()字符、字符串


operator+=()字符、字符串可以直接复用push\_back和append。

string& operator+=(char ch)
{
push_back(ch);
return *this;
}

string& operator+=(const char* str)
{
append(str);
return *this;
}


### 5.4 insert插入字符、字符串


#### 5.4.1 insert插入字符（在这提醒下，博主是所有的拷贝数据都是从’\0’开始，这样就不需要单独对’\0’做处理）


insert插入字符逻辑上还是很简单的。  
 首先判断插入字符时是否需要扩容。然后从下标为pos开始，所有数据依次往后挪动。最后将待插入字符给到pos处即可。


##### 初学者最容易范的一个错误


但对于初学者来说，貌似也不太轻松。。。。。。  
 下面给出各位初学者容易犯的错误：

void insert(size_t pos, char ch)
{
assert(pos <= _size);
//扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
//挪动数据
size_t end = _size;
while (end >= pos)
{
_str[end+1] = _str[end];
end–;
}
_str[pos] = ch;
_size++
}


这样对吗？答案是错误的。



> 
> 假设是在头插字符，end理论上和pos(即0)比较完后就减到-1，在下一次循环条件比较时失败，退出循环。  
>  遗憾的是end是size\_t类型，始终>=0, 会导致死循环。
> 
> 
> 


博主在这给出两种解决方法：


1. 将pos强转为整型。

void insert(size_t pos, char ch)
{
assert(pos <= _size);
//扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
//挪动数据
int end = _size;
while (end >= (int)pos)
{
_str[end+1] = _str[end];
end–;
}
_str[pos] = ch;
_size++
}


2.从end从最后数据的后一位开始，每次将前一个数据移到当前位置。最后条件判断就转化为end>pos，不会出现死循环这种情况。  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/b6aeb1939a7249068f81a936eaaed55d.png)

void insert(size_t pos, char ch)
{
assert(pos <= _size);
//扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
//挪动数据
size_t end = _size+1;
while (end > pos)
{
_str[end] = _str[end-1];
end–;
}
//插入数据，更新_size
_str[pos] = ch;
_size++;
}


#### 5.4.2 insert插入字符串


insert同样存在相同问题，并且思路一样。博主就直接给出代码了。  
 法一：

void insert(size_t pos, const char* str)
{
int len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}

int end = _size;
while (end >= (int)pos)
{
	_str[end + len] = _str[end];
	end--;
}
strncpy(_str + pos, str, len);
_size += len;

}


法二：

void insert(size_t pos, const char* str)
{
int len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}

size_t end = _size+1;
while (end > pos)
{
	_str[end + len-1] = _str[end-1];
	end--;
}
strncpy(_str + pos, str, len);
_size += len;

}


### 5.5 erase


erase分两种情况：


1. 从pos开始，要删的数据个数超过的字符串，即将pos后序所有数据全部情况。（直接将pos处数据置为’\0’即可）
2. 从pos开始，要删的数据个数没有超出的字符串。所以只需要从pos+len位置后的所有数据向前移动从pos位置覆盖原数据即可。

void erase(size_t pos, size_t len = npos)
{
if (len==npos || pos + len >= _size)
{
//有多少，删多少
_str[pos] = ‘\0’;
_size = pos;
}
else
{
size_t begin = pos + len;
while (begin <= _size)
{
_str[begin - len] = _str[begin];
begin++;
}
_size -= len;
}
}


## 六、 关系操作符重载：< 、 ==、 <=、 >、>=、!=

bool operator<(const string& s) const
{
return strcmp(_str, s._str) < 0;
}

bool operator==(const string& s) const
{
return strcmp(_str, s._str) == 0;
}

bool operator<=(const string& s) const
{
return *this < s || *this == s;
}

bool operator>(const string& s) const
{
return !(*this <= s);
}

bool operator>=(const string& s) const
{
return !(*this < s);
}

bool operator!=(const string& s) const
{
return !(*this == s);
}


## 七、find查找字符、字符串、substr


### 7.1 find查找字符

size_t find(char ch, size_t pos = 0)
{
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}

return npos;

}


### 7.2 find查找字符串

size_t find(const char* sub, size_t pos = 0)
{
const char* p = strstr(_str + pos, sub);
if §
{
return p - _str;
}
else
{
return npos;
}
}


### 7.3 strsub( ) 模拟实现


strsub目标长度可能越界string，也可能还有没有。但不管是那种情况，最后都需要拷贝数据。所以这里我们可以先将len真实长度计算出来，在拷贝数据。

string substr(size_t pos, size_t len = npos)const
{
string s;
size_t end = pos + len;
//目标字符越界string,更新len
if (len == npos || end >= _size)
{
len = _size - pos;
end = _size;
}

//拷贝数据
s.reserve(len);
for (size_t i = pos; i < end; i++)
{
	s += _str[i];
}

return s;

}


## 八、流插入和流提取（<<、>>）(实现在string类外)


### 8.1 流插入<<


由于前面我们实现了迭代器，所以最简单的方式就是范围for

ostream& operator<<(ostream& out, const string& s)
{
/*for (size_t i = 0; i < s.size(); i++)
{
out << s[i];
}*/
for (auto ch : s)
out << ch;

return out;

}


### 8.1 流提取>>


流提取比较特殊。在流提取前需要将原有数据全部清空。同时由于>>无法获取空字符和换行符()(都是作为多个值之间的间隔)，直接流提取到ostream对象中，没法结束。（类似于C语言中scanf, 换行符和空字符仅仅只是起到判断结束的作用，但scanf无法获取到它们）  
 所以这里博主直接调用istream对象中的get()函数。（类似于C语言中的getchar()函数）  
 [get详细文档](https://bbs.csdn.net/topics/618668825)  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/2af9ccef4f1e418f9311088576cdb6cb.png)

class string
{
void clear()
{
_str[0] = ‘\0’;
_size = 0;
}
private:
char* _str;
size_t _capacity;
size_t _size;
};

istream& operator>>(istream& in, string& s)
{
s.clear();
char ch;
//in >> ch;
ch = in.get();

	while (ch != ' ' && ch != '\n')
	{
		s += ch;
		//in >> ch;
		ch = in.get();
	}
	return in;
}


上面这种方法虽然可以达到目的。但还有一个问题，每次插入数据都面临可扩容问题。那如何优化呢？


#### 优化


其中一种办法就是调用reserve()提前开好空间，但这样面临这另一个问题：开大了浪费空间；开小了，同样面临这扩容的问题。  
 所以在这博主采用和vs底层实现的思路：首先开好一段数组（包含’\0’，以16为例）。当数据个数小于16时，字符串存在数组中；当数据个数大于等于16时，将数据存在\_str指向的空间。  
 这是一种以空间换时间的思路，同时也能很好的减少内存碎片的问题。

class string
{
void clear()
{
_str[0] = ‘\0’;
_size = 0;
}
private:
char* _str;
size_t _capacity;
size_t _size;
};

istream& operator>>(istream& in, string& s)
{
s.clear();

char buff[16];
size_t i = 0;

char ch;
ch = in.get();
while (ch != ' ' && ch != '\n')
{
	buff[i++] = ch;
	if (i == 16)
	{
		buff[i] = '\0';
		s += buff;
		i = 0;
	}
ch = in.get();
}

if (i != 0)
{
	buff[i] = '\0';
	s += buff;
}
return in;

}


## 九、所有代码

namespace achieveString
{
class string
{
public:
typedef char* iterator;
const typedef 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;
}

	//构造函数
	/\*string()

:_str(new char[1]{‘\0’})
,_capacity(0)
,_size(0)
{ }*/
string(const char* str = “”)
:_capacity(strlen(str))
, _size(_capacity)
{
_str = new char[_capacity + 1];
strcpy(_str, str);
}

	const char\* c\_str() const
	{
		return _str;
	}

	//析构函数
	~string()
	{
		delete[] _str;
		_str = nullptr;
		_size = _capacity = 0;
	}

	//拷贝构造
	/\*string(const string& s)

{
_str = new char[s._capacity + 1];
strcpy(_str, s._str);
_size = s._size;
_capacity = s._capacity;
}*/

	//交换
	void swap(string& s)
	{
		std::swap(_str, s._str);
		std::swap(_size, s._size);
		std::swap(_capacity, s._capacity);
	}

	//现代写法
	string(const string& s)
		:\_str(nullptr)
		,\_size(0)
		,\_capacity(0)
	{
		string tmp(s._str);
		swap(tmp);
	}

	// 赋值重载
	/\*string& operator=(const string& s)

{
if (this != &s)
{
char* tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;
_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;
}

	//可读可写
	char operator[](size_t pos)
	{
		assert(pos < _size);
		return _str[pos];
	}
	//只读
	const char operator[](size_t pos)const
	{
		assert(pos < _size);
		return _str[pos];
	}

	size_t size()const
	{
		return _size;
	}
	size_t capacity()const
	{
		return _capacity;
	}

	bool empty()const
	{
		return _size == 0;
	}

	void reserve(size_t n)
	{
		if (n > _capacity)
		{
			char\* tmp = new char[n + 1];
			strcpy(tmp, _str);
			delete[] _str;
			_str = tmp;
			_capacity = n;
		}
	}

	void resize(size_t n, char ch='\0')
	{
		if (n <= _size)
		{
			_str[n] = '\0';
			_size = n;
		}
		else
		{
			reserve(n);
			while (_size < n)
			{
				_str[_size] = ch;
				_size++;
			}
			_str[_size] = '\0';
		}
	}

	void push\_back(char ch)
	{
		//扩容
		if (_size == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity \* 2);
		}
		//插入数据
		_str[_size] = ch;
		_size++;
		_str[_size] = '\0';
	
	}

	void append(const char\* str)
	{
		size_t len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}
		strcpy(_str + _size, str);
		_size += len;
	}

	string& operator+=(char ch)
	{
		push\_back(ch);
		return \*this;
	}

	string& operator+=(const char\* str)
	{
		append(str);
		return \*this;
	}
	
	void insert(size_t pos, char ch)
	{
		assert(pos <= _size);
		//扩容
		if (_size == _capacity)
		{
			reserve(_capacity == 0 ? 4 : _capacity \* 2);
		}
		//挪动数据
		size_t end = _size+1;
		while (end > pos)
		{
			_str[end] = _str[end-1];
			end--;
		}
		//插入数据，更新\_size
		_str[pos] = ch;
		_size++;
	}
	void insert(size_t pos, const char\* str)
	{
		int len = strlen(str);
		if (_size + len > _capacity)
		{
			reserve(_size + len);
		}

		//法一
		/\*int end = \_size;

while (end >= (int)pos)
{
_str[end + len] = _str[end];
end–;
}
strncpy(_str + pos, str, len);
_size += len;*/

		//法二
		size_t end = _size+1;
		while (end > pos)
		{
			_str[end + len-1] = _str[end-1];
			end--;
		}
		strncpy(_str + pos, str, len);
		_size += len;
	}

	void erase(size_t pos, size_t len = npos)
	{
		if (len==npos || pos + len >= _size)
		{
			//有多少，删多少
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			size_t begin = pos + len;
			while (begin <= _size)
			{
				_str[begin - len] = _str[begin];
				begin++;
			}
			_size -= len;
		}
	}
	bool operator<(const string& s)const
	{

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

-1];
end–;
}
strncpy(_str + pos, str, len);
_size += len;
}

	void erase(size_t pos, size_t len = npos)
	{
		if (len==npos || pos + len >= _size)
		{
			//有多少，删多少
			_str[pos] = '\0';
			_size = pos;
		}
		else
		{
			size_t begin = pos + len;
			while (begin <= _size)
			{
				_str[begin - len] = _str[begin];
				begin++;
			}
			_size -= len;
		}
	}
	bool operator<(const string& s)const
	{

[外链图片转存中…(img-5F8Ccsuv-1715598551661)]
[外链图片转存中…(img-JROIJsIo-1715598551661)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84978645
关注
专栏目录
空间坐标转换： 布尔沙七参数（C++版本）
dayuhaitang1的博客
03-29 843
空间坐标转换： 布尔沙七参数（C++版本）
C++STL中swap函数操作与内存地址改变的简析
digitalkee的博客
07-18 1218
写在前面 这篇文章主要讨论了STL中swap函数在交换2个容器的内容的时候是交换内存还是交换元素的问题。由于博主对C++的学习并不好，如果有什么错误恳请大家提出。下面会有一些代码展示一下swap函数在对容器进行交换的时候对内存地址的影响，感兴趣的同学也可以自己写一下代码，会更加直观理解swap函数。 先放结论 swap函数会交换2个数据类型相同的容器内容。本身交换的速度非常快，因为swap在交换的时候并不是完全将2个容器的元素互换，而是交换了2个容器内的内存地址。除了数组，其他容器在交换后本质上是将内存地
c++介绍与入门基础（详细总结）
includeevey的博客
09-18 9792
该文章讲述c++的背景和基本知识。若认真看完就是对我最大的肯定。
C++实现高频设计模式
Coderwind的博客
11-16 499
C++实现高频设计模式
【C++】C++前言
2401_82610555的博客
07-23 1501
C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适。为了解决软件危机， 20世纪80年代， 计算机界提出了OOP(object oriented programming：面向对象)思想，支持面向对象的程序设计语言应运而生。1982年，Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念，发明了一 种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。C++是基于C语言而产生。
C++类的封装
BIUZJ的博客
09-12 1019
即开发过程中，以解释型的逐条语句执行方式来进行调试，以编译型的脱离开发环境而启动运行的方式来生成程序最终的执行代码。1.C++是一种面向对象的计算机程序设计语言，作为C语言的继承，C++不仅能进行C语言的过程化程序设计，而且可进行以抽象数据类型为特点的基于对象的程序设计，还能进行基于过程的程序设计；如果程序的编写是正确的，那么通常只需按一个功能键，即可搞定这个过程。该过程实际上分成两个步骤。封装：把一类事物的属性和行为用类这种自定义的数据类型包起来，把需要隐藏的隐藏起来，把可以暴露的暴露出来，这就叫封装。
C++常用代码
SylarChonna的博客
10-14 7141
C++手撕代码
【C++】【记录自己的自学过程】用string简单的写一个拼字小游戏，只需要掌握string find方法即可。
NVAS_CN的博客
09-10 654
C++ Primer Plus(第六版) 中文版 教材案例 自定义编程练习 用法简单，拓展性也较强，很适用于初学者练手 #include<iostream> #include<cctype> #include<string> #include<ctime> std::string shujuku_dongwu[15] = { "lion","tiger","panda","squirrel","raccoon", "Dog","cat","bir
<3>华为工程师 ，带你实战C++(2018版)-王桂林-专题视频课程
08-13 1300
这是一套全面而系统的C++学习教程： 1，C++对C的全面提高(类型增强，函数重载，默认参数，引用,new/delete 内联函数，类型强转，命名空间，系统string类。 2，封装，类与对象，友元，运算符重载。 3，继承与派生，多态，UML，设计模式。 4，文件IO流，模板，STL，,异常机制。...
学习笔记：c++多态、智能指针、动态内存
帅泽泽的博客
08-09 585
一、多态 1. 什么是多态 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。 C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。为了更为详细的说明多态，此处我们划分为**静态多态 **和 **动态多态 ** 两种状态来讲解 静态多态 静态多态是编译器在编译期间完成的，编译器会根据实参类型来选择调用合适的函数，如果有合适的函数可以调用就调，没有的话就会发出警告或者报错 。 该种方式的出现有两处地方： **函数重载 ** 和
【科研日常】2024年计算图形学与多媒体CCF A、B类会议投稿截止日期汇总
一只数模菜鸡的博客
10-01 791
整理了2024年多媒体方向的CCFA、B类学术会议的截稿时间，文末附有按月份排列的表格，各位同学可作为投稿参考。
【C语言】__attribute__((packed))与#pragma pack
W__winter的博客
09-28 362
在 C 语言中，是指编译器会根据不同的数据类型自动调整它们在内存中的位置，确保它们按照特定的字节边界存储。这种做法可以让处理器更高效地读取和存储数据。举个例子，像int这样的 4 字节数据通常会被对齐到 4 字节的边界上。如果前面有一个较小的数据类型，比如 1 字节的char，编译器可能会在它后面插入一些，让接下来的int保持在 4 字节边界上。虽然这样可以加快处理器的访问速度，但同时也会增加结构体的总大小，浪费一些内存。
69.【C语言】动态内存管理(重点)(2)
2401_85828611的博客
10-03 366
之前通过调用malloc来分配一块内存,calloc和recalloc是来释放内存块的,让内存块可以用于后续的分配。指针p的值没有变化,而且free函数不对之前分配的内存空间赋新值,只是交换给操作系统,因此没有变化。2.有分配内存空间(,malloc,calloc,recalloc)就有释放内存空间(free)2.参数ptr指向的空间为malloc,calloc或recalloc开辟的空间。3.如果参数ptr指向的空间不是动态开辟的，那free函数的行为是未定义的。1.虽然free函数没有改变指针的值,
①三菱Modbus主站MELSEC转ModbusRTU/ASCII工业MELSEC网关串口服务
梧桐林的博客
09-29 1193
MS-A1-80X1 系列作为 MELSEC 通信的适配器进行动作。可通过 MELSEC 通信，将 MS-A1-80X1 系列产品通过 RS485 采集的仪器仪表之类的值作为通信数据输出到PLC。
②三菱Modbus主站MELSEC转ModbusRTU/ASCII工业MELSEC网关串口服务
梧桐林的博客
09-30 837
MS-A1-80X1 系列作为 MELSEC 通信的适配器进行动作。可通过 MELSEC 通 信，将 MS-A1-80X1 系列产品通过 RS485 采集的仪器仪表之类的值作为通信数据 输出到 PLC。
c语言实例 068
无限大的博客
09-30 413
大家好，欢迎来到无限大的频道今天给大家带来的是c语言。创建一个单链表，进行存储数据并且打印创建一个单链表的基本步骤包括定义链表节点的结构体、实现插入数据的功能，以及打印链表的内容。以下是一个简单的C语言示例，展示如何创建一个单链表并存储数据，然后打印出链表中的所有数据。 程序解析 结构体定义:函数定义:主函数工作流程:运行程序后，用户可以输入要插入的节点数量及每个节点的数据，程序将输出链表的内容。例如： 这个示例展示了如何使用C语言构建一个简单的单链表并进行基本操作。
【C语言系统编程】【第二部分：并发编程】2.2 线程同步
最新发布
10-04 1106
读写锁允许多个线程同时读，但如果有线程在写，则其他线程必须等待读操作和写操作完成。此示例程序展示了基本的线程同步机制，使用互斥锁和条件变量来协调线程的执行顺序。线程在等待某个条件满足前会先等待并阻塞在条件变量上，而主线程通过条件变量信号来通知条件已经满足，以便唤醒线程继续执行指定的任务。通过读写锁，可以实现读写并发控制，允许多个线程同时读取数据，而写操作则是排他的，保证只有一个线程能进行写入操作。互斥锁（Mutex）是一种用于实现线程间同步的机制，它能够确保在任意时刻只有一个线程能够访问特定的资源。
c语言和c++一样吗
weixin_43187635的博客
09-28 368
C语言和C++并不一样，尽管它们有很多相似之处。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值