如何在建设银行网站申购纪念币,做网站推广怎么找客户,上海市建设监理协会网站,网站开发工程师待遇目录 一.类的声明 二.确定成员变量 三.成员函数 1.带参的构造函数#xff0c;析构函数#xff0c;拷贝构造 2.size()与capacity() 3.运算符重载 重载数组下标访问[] 重载 重载比较运算符#xff08;#xff0c; #xff0c; #xff0c; …目录 一.类的声明 二.确定成员变量 三.成员函数 1.带参的构造函数析构函数拷贝构造 2.size()与capacity() 3.运算符重载 重载数组下标访问[] 重载   重载比较运算符          !  重载流插入与流提取 重载 ​编辑 4.实现迭代器 使用迭代器遍历 使用范围for遍历 5.实现reserve(size_t n) 6.实现push_back(char ch) 7.实现append(const char* str) 8.实现insert() 9.实现erase() 10.实现clear() 11.实现resize() 12实现find() 13.实现substr 一.类的声明 为了避免与库函数里的string类重复定义这里我们用命名空间将我们自己定义的string类封到命名空间里代码为 namespace wzy {class string{public://成员变量private://成员函数}; } 二.确定成员变量 我们知道库里面的string类底层大致是使用的是一个字符指针指向一个数组然后将对数组的各种操作封装到类中然后是两个size_t类型的变量记录字符的空间与有效字符的个数。这里我们的成员变量可以参考 // 成员变量char* _str //指向存储字符的数组(数组空间大小包含\0) size_t _size //记录数组中有效字符的个数(不包含\0) size_t _capacity //记录数组空间的大小(不包含\0) 三.成员函数 1.带参的构造函数析构函数拷贝构造 string(const char* str):_str(new char[strlen(str)1]),_size(strlen(str)),_capacity(_size1){} 注在使用初始化列表的时候要注意类中成员变量的顺序!!! 原因初始化列表是按照变量声明的顺序初始化的建议初始化列表的顺序与成员变量声明的顺序一致. C规定常量字符串结尾自动加上\0因此这里缺省值相当于\0 析构函数 ~string(){delete[] _str;_str nullptr;_size _capacity0;}拷贝构造 string(const string s){_str new char[s._size 1];strcpy(_str, s._str);_size s._size;_capacity s._capacity;} 2.size()与capacity() size_t size() const{return _size;}size_t capacity() const{return _capacity;} 3.运算符重载 重载数组下标访问[] 可读可写 char operator[](size_t pos){assert(pos _size);return _str[i];} 可读不可写给被const修饰的string对象使用 const char operator[](size_t pos) const{assert(pos _size);return _str[i];} 使用数组下标的方式遍历string对象 void test1() {string s(Hello World!);for(size_t i0;is.size();i){couts[i] ;} } 重载   string operator(char ch){push_back(ch);return *this;}string operator(char* str){append(str);return *this;} 重载比较运算符          !  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);}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);} 重载流插入与流提取 ostream operator(ostream out, const string s) {for (auto ch : s) //要先实现const迭代器{out ch;}return out;}istream operator(istream in, string s){s.clear(); //用之前先清空schar ch;chin.get(); //为什么不用inch?//流提插入时不能遇到空格或换行就停止while (ch ! ch ! \n){s ch;chin.get();}return in;} 这里我们可以发现在流提取时当s满时再插入每插入一次就要扩容一次。这样效率不好。可以改为 istream operator(istream in, string s){s.clear(); char ch;char buff[128];chin.get(); size_t i0;while (ch ! ch ! \n){buff[i]ch;if(i129){buff[i]\0;sbuff;i0;}chin.get();}if(i){sbuff;}return in;} 这里我们用buff暂存字符当buff满时就尾插。结束当buff还有字符时再尾插。这样可以减少开辟空间的次数。 重载 string operator(const string s){if (this ! s){char* temp new char[s._capacity 1];strcmp(temp, s._str);delete[]_str;_str temp;_size s._size;_capacity s._capacity;}} 这里我们可以看到里面的交换数据次过多那我们能不能将其封装到一个函数里呢 这里首先要介绍一个库函数std::swap(),功能交换两个变量的值。变量只能是内置类型 void swap(string s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}string operator(string temp){swap(temp);return *this;} 注这里参数temp不能用引用被const修饰。 4.实现迭代器 这里我们一定要知道迭代器很多行为与指针类似。当很多情况下我们完全可以把迭代器当创指针使用。。因为迭代器也代表指向某个元素迭代器指向下一个元素与指针的方式一样迭代器也可以解引用使用元素。 这里我们实现迭代器的方式使用typedef 将char* 重命名为iterator。因此在这里我们完全可以将迭代器当作指针使用。 正向迭代器 typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str _size;} const迭代器 typedef const char* const_iterator;const_iterator begin() const{return _str;}const_iterator end() const{return _str _size;} 使用迭代器遍历 void test2() {string s(Hello World!);string::iterator it s.begin();while (it ! s.end()){cout *it ;}cout endl; } 使用范围for遍历 我们知道范围for的底层就是使用迭代器实现的因此当我们实现迭代器之后就可以使用范围for了。 void test3() {string s(Hello World!);for(auto ch:s){coutch ;}cout endl; } 5.实现reserve(size_t n) 按照库的方式分为两种情况 1.  n_capacity 。 扩容(申请新空间拷贝旧空间释放旧空间_str指向新空间更新_size与_capacity的值) 2. n_capacity  。不做处理 注这里_str指向新空间我们可以使用std::swap 作用交换两个内置类型的值. 只改变 _capacity不改变 _size void reserve(size_t n){if (n _capacity){char* temp new char[n1]; //需要为\0开辟空间strcpy(temp, _str);std::swap(temp, _str);delete[]temp;_capacity n;}} 6.实现push_back(char ch) 这里我们实现push_back按照库里面的方式。 这里我们可以分两种情况 1._size_capacity。扩容(使用reserve)然后尾插 2._size_capacity。直接尾插 void push_back(char ch){if (_size _capacity){reserve(_capacity0?4:_capacity*2);//注意当_capacity0时}_str[_size] ch;_size;_str[_size] \0;} 7.实现append(const char* str) 分两种情况 1. _sziestrlen(str)_capacity 。扩容(使用reserve)然后再将str的内容拷贝到_str里 2._sziesizeof(str)_capacity。 直接拷贝 void append(const char* str){size_t len strlen(str);if (_size len _capacity) //第一种情况{reserve(_size len);//这里的扩容具体还得看要求}strncpy(_str_size,str,len);//strncpy可以把\0也拷贝过来_size len;} 8.实现insert() string底层用的是数组这里在将一个字符或字符串插入某个位置可以看作像数组里插入。 string insert(size_t pos, char ch){assert(pos _size); //检查插入位置是否正确if (_size _capacity)//检测是否扩容{reserve(_capacity 0 ? 4 : _capacity * 2);}//这里要注意size_t是无符号的整形要注意头插时i的初始化值//这里即使i为整形i也会被整形提升为size_t类型for (size_t i _size1; i pos; i--) {_str[i] _str[i - 1];}_str[pos] ch;_size;}string insert(size_t pos, const char* str){assert(pos _capacity);int len strlen(str);if (pos len _capacity) //检查是否扩容{reserve(pos len);}for (int i _size; i (int)pos; i--){_str[ilen] _str[i];}strncpy(_str pos, str, len);_size len;return *this;} 9.实现erase() void erase(size_t pos, size_t len npos){assert(pos _size);if (len npos || poslen _size){_str[pos] \0;_size pos;}else{size_t begin pos len;while (begin _size){_str[begin - len] _str[begin];begin;}_size - len;}} 这里npos时一个无符号的整形是size_t类型最大的整数比特为全为1所以直接赋值为1. 因为npos属于string类的成员变量它的值不变因此我们可以用const与static修饰它。我们知道被static修饰的变量要在类外面定义但是C11中const修饰的static的成员变量只能是整形,可以直接在类里面给缺省值 10.实现clear() void clear(){_str[0] \0;_size 0;} 11.实现resize() 以库里面的resize为例分三种情况 1.  n_capacity  ,扩容初始化多出来的空间。 2.  _sizen_capcity  ,将大于_size小于n的空间初始化。 3. n_size , 缩容 void resize(size_t n, char ch \0){if (n _capacity){_str[n] \0;_size n;}else{reserve(n);int i;for (i _size; i n; i){_str[i] ch;}_str[i] \0;}} 12实现find() 在字符串中查找子串在理论上效率很高但是在实际上效率并不好所以我们一般用可以直接暴力查找。这里我们直接用了一个strstr()函数查找。 找到就返回子串的首地址没找到就返回空指针。 size_t find(char ch, size_t pos 0){assert(pos _size);for (size_t i pos; i _size; i){if (_str[i] ch){return i;}}return npos;}size_t find(const char* sub, size_t pos 0){const char* p strstr(_str, sub);if (p){return p-_str;}return npos;} 13.实现substr 分两种情况: 1. poslen_size, 2.poslen _size string substr(size_t pos, size_t len npos){assert(pos _size);string s;size_t end len pos;if (lennpos||pos len _size ){len _size - pos;end _size;}s.reserve(len);for (size_t i pos; i end; i){s _str[i];}return s;} 注使用这个函数时要先实现拷贝构造否则在传返回值的时候是浅拷贝会报错。 完整代码 因为string类的方法太多这里我只选了几个我们经常使用的实现大家可以参考我这个头文件继续实现下去 #pragma once #includeiostream#includeassert.h using namespace std;namespace wzy {class string{public:string(const char* str ):_str(new char[strlen(str) 1]), _size(strlen(str)), _capacity(_size 1){}string(const string s){_str new char[s._size 1];strcpy(_str, s._str);_size s._size;_capacity s._capacity;}~string(){delete[] _str;_str nullptr;_size _capacity 0;}size_t size(){return _size;}size_t capacity(){return _capacity;}char operator[](int i){assert(i _size);return _str[i];}typedef char* iterator;typedef const 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;}void reserve(size_t n){if (n _capacity){char* temp new char[n 1];strcpy(temp, _str);std::swap(temp, _str);delete[]temp;_capacity n;}}void push_back(char ch){if (_size _capacity){reserve(_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);//这里的扩容具体还得看要求}strncpy(_str _size, str, len);//strncpy可以把\0也拷贝过来_size len;}string operator(char ch){push_back(ch);return *this;}string operator(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);}for (size_t i _size 1; i pos; i--){_str[i] _str[i - 1];}_str[pos] ch;_size;}string insert(size_t pos, const char* str){assert(pos _capacity);int len strlen(str);if (pos len _capacity){reserve(pos len);}for (int i _size; i (int)pos; i--){_str[i len] _str[i];}strncpy(_str pos, str, len);_size len;return *this;}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);}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);}string operator(const string s){if (this ! s){char* temp new char[s._capacity 1];strcmp(temp, s._str);delete[]_str;_str temp;_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 operator(string s){if (this ! s){swap(s);return *this;}}void clear(){_str[0] \0;_size 0;}void erase(size_t pos, size_t len npos){assert(pos _size);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;}}void resize(size_t n, char ch \0){if (n _capacity){_str[n] \0;_size n;}else{reserve(n);int i;for (i _size; i n; i){_str[i] ch;}_str[i] \0;}}size_t find(char ch, size_t pos 0){assert(pos _size);for (size_t i pos; i _size; i){if (_str[i] ch){return i;}}return npos;}size_t find(const char* sub, size_t pos 0){const char* p strstr(_str, sub);if (p){return p-_str;}return npos;}string substr(size_t pos, size_t len npos){assert(pos _size);string s;size_t end len pos;if (lennpos||pos len _size ){len _size - pos;end _size;}s.reserve(len);for (size_t i pos; i end; i){s _str[i];}return s;}private:char* _str;size_t _size;size_t _capacity;public:const static size_t npos;};const size_t string::npos -1;ostream operator(ostream out, const string s){for (auto ch : s){out ch;}return out;}istream operator(istream in, string s){s.clear();char ch;chin.get() ;while (ch ! ch ! \n){s ch;chin.get();}return in;} }