初识c++（string和模拟实现string）
一、标准库中的string类
string类的文档介绍：cplusplus.com/reference/string/string/?kw=string
1、auto和范围for
auto：
在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，后来这个
不重要了。C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型
指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期
推导而得。
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际
只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
auto不能作为函数的参数，可以做返回值，但是建议谨慎使用
auto不能直接用来声明数组
#include<iostream>
using namespace std;
int func1()
{
return 10;
}
// 不能做参数
void func2(auto a)
{}
// 可以做返回值，但是建议谨慎使用
auto func3()
{
return 3;
}
int main()
{
int a = 10;
auto b = a;
auto c = 'a';
auto d = func1();
// 编译报错:rror C3531: “e”: 类型包含“auto”的符号必须具有初始值设定项
auto e;
cout << typeid(b).name() << endl;//查看变量类型
cout << typeid(c).name() << endl;
cout << typeid(d).name() << endl;
int x = 10;
auto y = &x;
auto* z = &x;
auto& m = x;
cout << typeid(x).name() << endl;
cout << typeid(y).name() << endl;
cout << typeid(z).name() << endl;
auto aa = 1, bb = 2;
// 编译报错：error C3538: 在声明符列表中，“auto”必须始终推导为同一类型
auto cc = 3, dd = 4.0;
// 编译报错：error C3318: “auto []”: 数组不能具有其中包含“auto”的元素类型
auto array[] = { 4, 5, 6 };
return 0;
}
范围for
对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此
C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围
内用于迭代的变量，第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。
范围for可以作用到数组和容器对象上进行遍历
范围for的底层很简单，容器遍历实际就是替换为迭代器，这个从汇编层也可以看到。
#include<iostream>
#include <string>
#include <map>
using namespace std;
int main()
{
int array[] = { 1, 2, 3, 4, 5 };
// C++98的遍历
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
{
array[i] *= 2;
}
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
{
cout << array[i] << endl;
}
// C++11的遍历
for (auto& e : array)
e *= 2;
for (auto e : array)
cout << e << " " << endl;
string str("hello world");
for (auto ch : str)
{
cout << ch << " ";
}
cout << endl;
return 0;
}
2、string常见接口
1、 string类对象的常见构造
void Teststring()
{
string s1; // 构造空的string类对象s1
string s2("hello bit"); // 用C格式字符串构造string类对象s2
string s3(s2); // 拷贝构造s3
}
2、string类对象的容量操作
注意：
- size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接
口保持一致，一般情况下基本都是用size()。
-
clear()只是将string中有效字符清空，不改变底层空间大小。
-
resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不
同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char
c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数
增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
- reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参
数小于string的底层空间总大小时，reserver不会改变容量大小。
3、string类对象的访问及遍历操作
4、string类对象的修改操作
注意：
- 在string尾部追加字符时，s.push_back© / s.append(1, c) / s += 'c’三种的实现方式差
不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可
以连接字符串。
- 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留
好。
5、string类非成员函数
6、vs和g++下string结构的说明
注意：下述结构是在32位平台下进行验证，32位平台下指针占4个字节。
vs下string的结构
string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体用来定义
string中字符串的存储空间：
当字符串长度小于16时，使用内部固定的字符数组来存放
当字符串长度大于等于16时，从堆上开辟空间
union _Bxty
{ // storage for small buffer or pointer to larger one
value_type _Buf[_BUF_SIZE];
pointer _Ptr;
char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;
这种设计也是有一定道理的，大多数情况下字符串的长度都小于16，那string对象创建
好之后，内部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。
其次：还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的
容量
最后：还有一个指针做一些其他事情。
故总共占16+4+4+4=28个字节。
g++下string的结构**
G++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个
指针，该指针将来指向一块堆空间，内部包含了如下字段：
空间总大小
字符串有效长度
引用计数
struct _Rep_base
{
size_type _M_length;
size_type _M_capacity;
_Atomic_word _M_refcount;
};
二、string类的模拟实现
1、构造和析构
对于构造和析构这种频繁调用的函数可以直接在类里面写设为inline
构造：
string(const char* str = "")//空拷贝时就一个\0套到下面可以实现。
{
_size = strlen(str);//
// _capacity计算大小不包含\0
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);//把原来的数据拷贝过来。
}
拷贝构造：（拷贝构造一定要深拷贝）
string(const string& s)//拷贝构造
{
_size = s._size;
_capacity = _capacity;
_str = new char[_capacity + 1];
strcpy(_str, s._str);//把原来的数据拷贝过来。
}
析构：
~string()
{
delete[] _str;
_str = nullptr
_capacity = _size = 0;
}
赋值：
string& operator=(const string& s)
{
if (this != &s)//两个是不同的
{
delete[] _str;
_str = new char[s._capacity + 1];//开的时候比capacity多开一个保证两个空间相同。
strcpy(_str, s._str);
_size = s._size;
_capacity = s._capacity;
}
return *this;//两个相同返回本身。
}
深浅拷贝问题：
浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致
多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该
资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。
深拷贝：如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。
一般情况都是按照深拷贝方式提供。
2、迭代器
string的迭代器本质就是指针。
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
3、容量操作
size_t size()
{
return _size;;
}
size_t capacity()const
{
return _capacity;
}
bool empty()const
{
return _size == 0;
}
void clear()
{
*_str = '\0';//第一个为\0
_size = 0;//长度为0
}
char& operator[](size_t index)
{
assert(index < _size);
return _str[index];
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
void string::reserve(size_t n)
{
if (n > _capacity)//大了才能改
{
auto* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
else
{
perror("reserve fail");
}
}
void string::resize(size_t n, char c)
{
if (_size > n)
{
_str[n] = c;
_size = n;
}
else
{
reserve(n);//扩空间
for (size_t i = _size; i < n; i++)
{
_str[i] = c;
}
_size = n;
}
}
4、修改操作
void string::push_back(char c)
{
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = c;
++_size;
_str[_size] = '\0';
}
void string::append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
// 大于2倍，需要多少开多少，小于2倍按2倍扩
reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
}
strcpy(_str + _size, str);
_size += len;
}
string& string::operator+=(char c)
{
push_back(c);
return *this;
}
string& string::operator+=(const char* str)
{
append(str);
return *this;
}
size_t string::find(char c, size_t pos) const
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == c)
{
return i;
}
}
return npos;
}
size_t string::find(const char* str, size_t pos) const
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, str);//直接用找字串的函数
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}
string& string::insert(size_t pos, char c)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
for (size_t i = _size + 1; i > pos; i--)
{
_str[i] = _str[i - 1];
}
_str[pos] = c;
++_size;
return *this;
}
string& string::insert(size_t pos, const char* str)
{
assert(pos <= _size);
if (_size + strlen(str) > _capacity)
{
// 大于2倍，需要多少开多少，小于2倍按2倍扩
reserve(_size + strlen(str) > 2 * _capacity ? _size + strlen(str) : 2 * _capacity);
}
for (size_t i = _size + 1 + strlen(str); i > pos ; i--)
{
_str[i] = _str[i - strlen(str)];
}
for (size_t i = 0; i < strlen(str); i++)//用strcpy有数据丢失风险
{
_str[pos + i] = str[i];
}
_size += strlen(str);
return *this;
}
string& string::erase(size_t pos, size_t len)
{
assert(pos < _size);
if (len >= _size - pos)//大于就全删
{
_str[pos] = '\0';
_size = pos;
}
else
{
for (size_t i = pos + len; i <= _size; i++)//把len长度删了
{
_str[i - len] = _str[i];
}
_size -= len;
}
}
5、比较操作
比较操作放在类外面比较好用
bool operator<(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator<=(const string& s1, const string& s2)
{
return s1 < s2 || s1 == s2;
}
bool operator>(const string& s1, const string& s2)
{
return !(s1 <= s2);
}
bool operator>=(const string& s1, const string& s2)
{
return !(s1 < s2);
}
bool operator==(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator!=(const string& s1, const string& s2)
{
return !(s1 == s2);
}
6、cout和cin
ostream& operator<<(ostream& _cout, const str::string& s)
{
for (auto ch : s)
{
_cout << ch;
}
return _cout;
}
istream& operator>>(istream& in, string& s)
{
s.clear();//每次读之前清理一下
const int N = 256;
char buff[N];//定义一个buff数组避免频繁扩容
int i = 0;
char ch;
//in >> ch;//不用>>是因为它默认以空格和换行为分割符。
ch = in.get();
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;//满了就加给s
i = 0;
}
ch = in.get();
}
if (i > 0)
{
buff[i] = '\0';//出来如果每满加\0并给s
s += buff;
}
return in;
}
}
7、所有文件
string.h
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<iostream>
#include<string>
#include<assert.h>
using namespace std;
namespace str
{
class string
{
public:
typedef char* iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
typedef const char* const_iterator;
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
public:
string(const char* str = "")//空拷贝时就一个\0套到下面可以实现。
{
_size = strlen(str);
// _capacity计算大小不包含\0
_capacity = _size;
_str = new char[_capacity + 1];//多开一个放\0
strcpy(_str, str);//把原来的数据拷贝过来。
}
string(const string& s)//拷贝构造
{
_size = s._size;
_capacity = _capacity;
_str = new char[_capacity + 1];
strcpy(_str, s._str);//把原来的数据拷贝过来。
}
string& operator=(const string& s)
{
if (this != &s)//两个是不同的
{
delete[] _str;
_str = new char[s._capacity + 1];//开的时候比capacity多开一个保证两个空间相同。
strcpy(_str, s._str);
_size = s._size;
_capacity = s._capacity;
}
return *this;//两个相同返回本身。
}
~string()
{
delete[] _str;
_str = nullptr;
_capacity = _size = 0;
}
void push_back(char c);
string& operator+=(char c);
void append(const char* str);
string& operator+=(const char* str);
const char* c_str() const;
void clear()
{
*_str = '\0';//第一个为\0
_size = 0;//长度为0
}
/
// capacity
size_t size()
{
return _size;;
}
size_t capacity()const
{
return _capacity;
}
bool empty()const
{
return _size == 0;
}
void resize(size_t n, char c = '\0');
void reserve(size_t n);
/
// access
char& operator[](size_t index)
{
assert(index < _size);
return _str[index];
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
/
//relational operators
// 返回c在string中第一次出现的位置
size_t find(char c, size_t pos = 0) const;
// 返回子串s在string中第一次出现的位置
size_t find(const char* s, size_t pos = 0) const;
// 在pos位置上插入字符c/字符串str，并返回该字符的位置
string& insert(size_t pos, char c);
string& insert(size_t pos, const char* str);
// 删除pos位置上的元素，并返回该元素的下一个位置
string& erase(size_t pos, size_t len);
private:
char* _str;
size_t _capacity;
size_t _size;
static size_t nops;
};
ostream& operator<<(ostream& _cout, const str::string& s);
istream& operator>>(istream& _cin, str::string& s);
static size_t npos = -1;
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);
bool operator!=(const string& s1, const string& s2);
}
string.c
#include"string.h"
#include<iostream>
using namespace std;
namespace str
{
void string::reserve(size_t n)
{
if (n > _capacity)//大了才能改
{
auto* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
else
{
perror("reserve fail");
}
}
void string::resize(size_t n, char c)
{
if (_size > n)
{
_str[n] = c;
_size = n;
}
else
{
reserve(n);//扩空间
for (size_t i = _size; i < n; i++)
{
_str[i] = c;
}
_size = n;
}
}
void string::push_back(char c)
{
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = c;
++_size;
_str[_size] = '\0';
}
void string::append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
// 大于2倍，需要多少开多少，小于2倍按2倍扩
reserve(_size + len > 2 * _capacity ? _size + len : 2 * _capacity);
}
strcpy(_str + _size, str);
_size += len;
}
string& string::operator+=(char c)
{
push_back(c);
return *this;
}
string& string::operator+=(const char* str)
{
append(str);
return *this;
}
size_t string::find(char c, size_t pos) const
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == c)
{
return i;
}
}
return npos;
}
size_t string::find(const char* str, size_t pos) const
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, str);//直接用找字串的函数
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}
string& string::insert(size_t pos, char c)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
for (size_t i = _size + 1; i > pos; i--)
{
_str[i] = _str[i - 1];
}
_str[pos] = c;
++_size;
return *this;
}
string& string::insert(size_t pos, const char* str)
{
assert(pos <= _size);
if (_size + strlen(str) > _capacity)
{
// 大于2倍，需要多少开多少，小于2倍按2倍扩
reserve(_size + strlen(str) > 2 * _capacity ? _size + strlen(str) : 2 * _capacity);
}
for (size_t i = _size + 1 + strlen(str); i > pos ; i--)
{
_str[i] = _str[i - strlen(str)];
}
for (size_t i = 0; i < strlen(str); i++)//用strcpy有数据丢失风险
{
_str[pos + i] = str[i];
}
_size += strlen(str);
return *this;
}
string& string::erase(size_t pos, size_t len)
{
assert(pos < _size);
if (len >= _size - pos)//大于就全删
{
_str[pos] = '\0';
_size = pos;
}
else
{
for (size_t i = pos + len; i <= _size; i++)//把len长度删了
{
_str[i - len] = _str[i];
}
_size -= len;
}
}
const char* string::c_str() const
{
return _str;
}
bool operator<(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator<=(const string& s1, const string& s2)
{
return s1 < s2 || s1 == s2;
}
bool operator>(const string& s1, const string& s2)
{
return !(s1 <= s2);
}
bool operator>=(const string& s1, const string& s2)
{
return !(s1 < s2);
}
bool operator==(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator!=(const string& s1, const string& s2)
{
return !(s1 == s2);
}
ostream& operator<<(ostream& _cout, const str::string& s)
{
for (auto ch : s)
{
_cout << ch;
}
return _cout;
}
istream& operator>>(istream& in, string& s)
{
s.clear();//每次读之前清理一下
const int N = 256;
char buff[N];//定义一个buff数组避免频繁扩容
int i = 0;
char ch;
//in >> ch;//不用>>是因为它默认以空格和换行为分割符。
ch = in.get();
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;//满了就加给s
i = 0;
}
ch = in.get();
}
if (i > 0)
{
buff[i] = '\0';//出来如果每满加\0并给s
s += buff;
}
return in;
}
}
原文地址：https://blog.csdn.net/suiyi_freely/article/details/140649136
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！