string STL容器尾插插入的操作。

最新推荐文章于 2024-11-06 16:11:12 发布

原创最新推荐文章于 2024-11-06 16:11:12 发布 · 504 阅读

CC 4.0 BY-SA版权

这篇博客探讨了C++中STL string对象的构造、拷贝构造函数和赋值运算符的实现，包括深拷贝与浅拷贝的区别，以及现代C++的拷贝构造和赋值运算符的实现方式。文章通过实例展示了如何避免内存泄漏和确保对象正确管理内存。

// 面向对象 STLstring 使用.cpp : 此文件包含 “main” 函数。程序执行将在此处开始并结束。
//
//#include
//
//int main()
//{
// std::cout << “Hello World!\n”;
//}
//
// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧:
// 1. 使用解决方案资源管理器窗口添加/管理文件
// 2. 使用团队资源管理器窗口连接到源代码管理
// 3. 使用输出窗口查看生成输出和其他消息
// 4. 使用错误列表窗口查看错误
// 5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
// 6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件

////string 使用
//#include
//#include
//using namespace std;
//class String
//{
//public:
// //String()
// // :_data(new char[1])
// //{
// // _data[0] = ‘\0’;
// //}
// //全缺省构造函数一般使用的就是全缺省的情况
// String(const char* str = “”)
// :_data(new char[strlen(str) + 1])
// {
// strcpy(_data, str);
// cout << “String(char*)” << endl;
// }
// const char* c_str() const
// {
//
// return _data;
// }
// ~String()
// {
// if (_data)
// {
// //析构函数的时候就是使用的是[]也是用删除连续空间大小的
// //注意资源申请是在堆上进行的，资源的释放也是在堆上的。
// delete[] _data;
// _data = nullptr;
// cout << “String()” << endl;
// }
//
// }
//private:
// char* _data;
//
//};
//void test()
//{
// String str;
// cout << str.c_str() << endl;
// String str2;
// cout << str2.c_str() << endl;
//}
//int main()
//{
// test();
// return 0;
//}

//
//#include
//#include
//using namespace std
////经典写法
//class String
//{
//public:
// //String()
// // :_data(new char[1])
// //{
// // _data[0] = ‘\0’;
// //}
// //全缺省构造函数一般使用的就是全缺省的情况
// String(const char* str = “”)
// :_data(new char[strlen(str) + 1])
// {
// strcpy(_data, str);
// cout << “String(char*)” << endl;
// }
// //由于会出现浅拷贝的问题，那么就是显示去重载进行深拷贝
// //之所以是深拷贝，就是因为有新开辟的空间，再去拷贝
// String(const String& str)
// //这里是开辟空间。
// //
// :_data(new char[strlen(str._data)+1])
// {
// strcpy(_data, str._data);
// }
////对应的是浅拷贝
//String(const String& str)
// :_data(str._data)
//{
// //函数体内是空的，只是地址的拷贝。
//}
// const char* c_str() const
// {
//
// return _data;
// }
// String& operator=(const String& str)
// {
// //深拷贝
// //判断是不是自己给自己赋值如果是自己就直接返回。
// if (this != &str)
// {
// //1.释放原有的空间
// delete[] _data;
// //2.申请新的空间
// _data = new char[strlen(str._data) + 1];
// //3.拷贝内容
// strcpy(_data, str._data);
// }
// return this;
// }
// ~String()
// {
// if (_data)
// {
// //析构函数的时候就是使用的是[]也是用删除连续空间大小的
// //注意资源申请是在堆上进行的，资源的释放也是在堆上的。
// delete[] _data;
// _data = nullptr;
// cout << “String()” << endl;
// }
//
// }
//private:
// char _data;
//};
//void test()
//{
// String str(“123”);
// //浅拷贝；只拷贝string对象中的内容拷贝构造
// //String copy(str);
// //赋值
// String str2 = str;//浅拷贝内存泄漏
// String str3;
// str2 = str;
// str3 = str2;
//
// //拷贝构造；判断是否是拷贝构造，就是需要去判断该对象是否是存在的，不存在就是拷贝构造，存在就是赋值。
// String str4 = str;
//
//}
//int main()
//{
// test();
// return 0;
//}

//
//#include
//#include
//using namespace std;
//class String
//{
//public:
//
// //全缺省构造函数一般使用的就是全缺省的情况这里使用的是const就是不发生改变。
// String(const char* str = “”)
// //根据长度进行空间的申请，并且是初始化。空间的申请使用new进行空间的申请。
// :_data(new char[strlen(str) + 1])
// {
// //调用默认的拷贝构造。
// strcpy(_data, str);
// cout << “String(char*)” << endl;
// }
// //现代写法；主要是代码的复用。复用构造函数的逻辑，完成实际的拷贝。
// //拷贝构造
// String(const String& str)
// {
// string tmp(str._data);
// //这里的交换就是交换指针的指向，从而实现空间的释放，完成拷贝的任务。
// swap(tmp._data, _data);
// }
// //现代写法的赋值的写法；
// //释放原有空间，申请新的空间，拷贝内容
// //赋值运算符；
// //1.通过一个形参对象，调用拷贝构造，完成；
// //a.新的空间申请
// //b.内容拷贝
// //2.调用形参对象的析构，完成
// //c.原有空间释放。
// String& operator=(const String& str)
// {
// string tmp(str._data);
// swap(tmp._data, _data);
// }
// ~String()
// {
// if (_data)
// {
// //析构函数的时候就是使用的是[]也是用删除连续空间大小的
// //注意资源申请是在堆上进行的，资源的释放也是在堆上的。
// delete[] _data;
// _data = nullptr;
// cout << “String()” << endl;
// }
// }
//private:
// char* _data;
//}:
//void test()
//{
// String str(“123”);
// String copy(str);
// String str2(“456”);
// str2 = str;
//
//}
//int main()
//{
// tets();
// return 0;
//}

#include<assert.h>
#include
#include
using namespace std;
//进行增删查改的操作就是类似于一个顺序表的操作。
class String
{
public:
//string的迭代器类似于字符指针。
//迭代器操作；类似于指针
//解引用：iterator–>获取内容
//移动++iterator,–iterator,移动到相邻的位置。
typedef char iterator;
typedef const char* const_iterator;
const_iterator begin() const
{
return _data;
}
const_iterator end()const
{
//最后元素的下一个位置。
return _data + _size;
}
String(const char* str = “”)
{
//提高性能
_size = strlen(str);
_data = new char[_size + 1];
_capacity = _size;

	strcpy(_data, str);
}
String(const string& str)
	:_data(nullptr)
	, _size(0)
	, _capacity(0)
{
	String tmp(str._data);
	swap(tmp);

}
//交换的函数
void swap(String& str)
{
	swap(_data,str._data);
	swap(_size,str._size);
	swap(_capacity,str._capacity);
}
String& operator=(String str)
{
	swap(str);
}
~String()
{
	if (_data)
	{
		delete[] _data;
		_data = nullptr;
		_size = _capacity = 0;
	}
}
//输出对应位置的内容
char& operator[](size_t pos)
{
	assert(pos < _size);
	return _data[pos];
}
//只读
const char& operator[](size_t pos) const
{
	assert(pos < _size);
	return _data[pos];
}
//返回当前有效字符的个数
size_t size() const
{
	return _size;
}
//尾插
void push_back(const char& ch)
{
	//检查空间
	if (_size == _capacity)
	{
		size_t newC = _capacity == 0?15:2 * _capacity;
		//增容  细节就是是不是为0
		reserve(newC);
	}
	_data[_size] = ch;
	_size++;
	//添加结束字符‘\0’ 保证是一个完整的字符串。
	_data[_size] = '\0';
}
void reserve(size_t n)
{
	if (n> _capacity)
	{
		//申请空间
		char* tmp = new char[n + 1];
		//拷贝
		strcpy(tmp, _data);
		//释放原有空间
		delete[] _data;
		//更新指向和容量。
		_data = tmp;
		_capacity = n;
	}

}
void resize(size_t n, const char& ch = '\0')
{
	//3.n>_capacity 增容
	if (n > _capacity)
	{
		reserve(n);
	}
	//2._size<n<=_capacity
	//填充字符 ch
	if(n>_size)
	memset(_data + _size, ch, (n - _size) * sizeof(char));
	//1.直接修改size
	_size = n;
	_data[_size] = '\0';
}
const char* c_str() const
{
	return _data;
}

private:
char* _data;
//size;有效字符的个数
size_t _size;
//capacity;可以保存的最大有效字符个数
size_t _capacity;
};
//void test()
//{
// String str = “0123456789”;
// for (size_t i = 0; i < str.size(); ++i)
// {
// cout << str[i] << “”;
// //str.operator;
// str[i] = ‘a’;
// str.operator = ‘b’;
// }
// cout << endl;
//
// //范围for 通过迭代器实现底层是迭代器的接口。
// for (const auto& ch : str)
// {
// cout << ch << “”;
// }
// cout << endl;
// //迭代器的使用方式
// String:: iterator it = str.begin();
// while (it != str.end())
// {
// cout << *it << “”;
// *it = ‘d’;//遍历完成之后就都是b了
// ++it;
// }
//}
//int main()
//{
// test();
// return 0;
//
//}
//
////const迭代器
//void printStringIt(const string& str)
//{
// string::const_iterator it = str.begin();
// while (it != str.end())
// {
// cout << *it << " ";
// //由于是const 所以不能进行修改
// ++it;
// }
// cout << endl;
//}
//
//void printStringFor(const string& str)
//{
// for (const char& ch : str)
// {
// cout << ch << “”;
// //ch=‘a’;
// }
// cout << endl;
//}

//尾插的操作
void test()
{
String str;
str.push_back(‘1’);
cout << str.c_str() << endl;
str.push_back(‘2’);
cout << str.c_str() << endl;
str.push_back(‘3’);
cout << str.c_str() << endl;
str.push_back(‘4’);
cout << str.c_str() << endl;
str.push_back(‘5’);
cout << str.c_str() << endl;
str.push_back(‘6’);
cout << str.c_str() << endl;
str.resize(3);//123
str.resize(10, a);//123aaaaaaa
str.resize(20, b);//123aaaaaaabbbbbbbbbb
}