当前位置：首页 > wzjs >正文

优秀个人网站主页做企业网站还有市场吗

wzjs 2025/9/19 20:28:46

优秀个人网站主页,做企业网站还有市场吗,宜昌市建设信息网站,临沂企业建站目录 string的构造函数无参数的构造函数根据字符串初始化用n个ch字符初始化用一个字符串的前n个初始化拷贝构造用另一个string对象的pos位置向后len的长度初始化 [ ]解引用重载迭代器的实现非const版本 const版本扩容reserve和resize reserve resize p…

string的构造函数

无参数的构造函数

根据字符串初始化

用n个ch字符初始化

用一个字符串的前n个初始化

拷贝构造

用另一个string对象的pos位置向后len的长度初始化

[ ]解引用重载

迭代器的实现

非const版本

const版本

扩容reserve和resize

reserve

resize

push_back和append

push_back

append

+=运算符重载

insert插入

erase删除

find

substr

流插入和流提取

比较

赋值运算符重载

补充

string是库中用于储存字符串的类，其底层实际上是顺序表。

namespace cfl
{class string{public:private:char* _str;        //指向储存字符串的起始位置size_t _size;      //存储有效字符个数size_t _capacity;  //存储开辟的空间总个数static size_t npos;};size_t string::npos = -1;
}

string中有一个静态变量是npos类型是size_t，但是定义是却定义为-1，所以npos强转为了无符号整形，也就是能存储size_t类型的最大值，其用来表示整个字符串。

string的构造函数

参考文献：string::string - C++ Referencehttps://legacy.cplusplus.com/reference/string/string/string/

string的构造一共有中其中有一种的实现需要迭代器，在下面实现迭代器的时候讲解，先完成前6种。

无参数的构造函数

//无参数的构造函数
string():_str(new char('\0'))   //此处不直接设置nullptr，将其设置为空字符串,_size(0),_capacity(0)
{}

根据字符串初始化

//根据字符串初始化的构造函数
string(const char* str):_size(strlen(str)), _capacity(strlen(str))
{_str = new char[_size];			//此处也可以在上面进行初始化，但是要注意顺序		memcpy(_str, str, _size + 1);   //_size+1是要拷贝'\0'
}

用n个ch字符初始化

//用n个ch字符初始化的构造函数
string(size_t n, const char ch):_str(new char[n+1])  //要开辟n+1个空间是为了存储'\0', _size(n), _capacity(n)
{memset(_str,ch, n);_str[_size] = '\0';
}

用一个字符串的前n个初始化

//用一个字符串的前n个初始化的构造函数
string(const char* str, size_t n):_str(new char[n + 1]), _size(n), _capacity(n)
{memcpy(_str, str, n);_str[_size] = '\0';
}

拷贝构造

//拷贝构造函数
string(const string& s)
{_capacity = s._capacity;_str = new char[_capacity + 1];_size = s._size;memcpy(_str, s._str, _size);_str[_size] = '\0';
}

用另一个string对象的pos位置向后len的长度初始化

//用另一个string对象的pos位置向后len的长度初始化的构造函数
string(const string& s, size_t pos, size_t len = npos) //len给一个缺省值是npos，代表整个字符串
{if (len == npos || len + pos >= s._size){len = s._size - pos;_capacity=len;_str = new char[_capacity + 1];_size = len;_str[_size] = '\0';}else{_capacity = len;_str = new char[_capacity + 1];_size = len;_str[_size] = '\0';}
}

[ ]解引用重载

string类对象可以像数组一样通过下标访问是因为解引用运算符重载。

char& operator[](size_t pos)
{return _str[pos];
}

迭代器的实现

迭代器实际上可以看成一个指针，但是其与指针有一些区别。范围for的底层逻辑就是迭代器，实现了迭代器，范围for才能使用。

非const版本

//迭代器的实现
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()  //begin就是返回起始位置的指针
{return _str;
}
iterator end()
{return _str + _size;  //返回最后一个字符下一个位置。
}

const版本

const_iterator begin()const    
{return _str;
}
const_iterator end()const
{return _str + _size;  
}

扩容reserve和resize

reserve

reserve扩容要帮助，传过去的参数比当前空间大才扩容，比当前空间小则不做处理。

void reserve(size_t n)
{if(n>_capacity){//先开辟新的空间，再将数据拷贝回来char* tmp= new char[n + 1];memcpy(tmp, _str, _size + 1);_str = tmp;_capacity = n;}
}

resize

resize和reverse扩容有所区别，传给resize的空间小于_size会将n后面的所有数据删除，resize还会对像开辟的空间进行初始化。

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

push_back和append

push_back

尾插直接向顺序表结尾插入数据,尾插是也要考虑扩容。

void push_back(char ch)
{if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}_str[_size] = ch;++_size;_str[_size] = '\0';
}

append

appened是直接在尾部插入字符串。

void append(const char* s)
{size_t len = strlen(s);if (_capacity == _size || len + _size > _capacity){reserve(len + _size);}memcpy(_str + _size, s, len + 1);_size = _size + len;
}

+=运算符重载

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

insert插入

insert有两种：在pos位置插入n个字符ch，在pos插入字符串。

void insert(size_t pos, size_t n, char ch)
{assert(pos < _size);//判断空间够不够if (n + _size < _capacity){reserve(n + _size);}//将数据向后移size_t end = _size;while (end >= pos){_str[end + n] = _str[end];--end;}//插入数据for (int i = 0; i < n; i++)_str[pos + i] = ch;
}

void insert(size_t pos, const char* str)
{assert(pos < _size);size_t len = strlen(str);if (_size == _capacity || len + _size > _capacity){reserve(len + _size);}int end = _size;while (end >= pos){_str[end + len] = _str[end];--end;}for (int i = 0; i < len; i++)_str[pos + i] = str[i];
}

erase删除

从pos位置删除len的长度。

void erase(size_t pos, size_t len = npos)
{if (len == npos || pos + len >= _size){_str[pos] = '\0';_size = pos;}else{int end = pos+len;while (end < _size){_str[end - len] = _str[end];++end;}_size -= len;_str[_size] = '\0';}
}

find

从pos位置向后找字符ch。

size_t find(size_t pos, const char ch)
{assert(pos < _size);int cur = pos;while (cur < _size){if (_str[cur] == ch)return cur;++cur;}return npos;  //表示没找到
}

substr

返回冲pos位置开始取n个字符的子字符串。

string substr(size_t pos, size_t n)
{int end = pos + n;if (end > _size){end = _size;}string s;for (int i = pos; i < end; i++)s += _str[i];return s;
}

流插入和流提取

流插入和流提取要放在类外定义，具体原因在<类和对象>该文种有讲解。

//流插入
ostream& operator<<(ostream& out, const cfl::string& s)
{for (auto e : s)out << e;  //使用循环for可以防止s中间有\0导致停止return out;
}
istream& operator>>(istream& in, cfl::string& s)
{//每次插入一个字符会导致每次尾插都要开空间//设置一个数组，先将字符插入到数组中，再将数组插入到s中char tmp[128];char ch = in.get();//此处使用in.get可以读取输入流中的空格int i = 0;while (ch != '\n'){tmp[i++] = ch;if (i == 127){tmp[127] = '\0';i = 0;s += tmp;}ch = in.get();}tmp[i] = '\0';s += tmp;return in;
}

注意：流插入重载和流提取重载都是string的友元函数。

比较

此处仅实现>和==，其他比较可以直接套用他们两个。

bool operator<(const string& s)
{size_t end1 = _size;size_t end2 = s._size;int i = 0;while (i < end1 && i < end2){if (_str[i] < s._str[i])return true;else if (_str[i] > s._str[i])return false;i++;}if (i < end1)return true;return false;
}bool operator==(const string& s)
{if (_size != s._size)return false;int i = 0;while (i < _size){if (_str[i] != s._str[i])return false;i++;}return true;
}

赋值运算符重载

void swap(string& s)
{std::swap(this->_str, s._str);std::swap(this->_capacity, s._capacity);std::swap(this->_size, s._size);
}string& operator=(string tmp)
{swap(tmp);  //此处的tmp是临时变量，又是原对象的拷贝//所以直接将tmp与*this，交换，实现赋值//因为tmp是临时变量出作用域后会将*this的空间释放return *this;
}