0
0

【C++标准库】模拟实现string+深浅拷贝问题

模拟实现string类

一.命名空间与类成员变量

  根据string的结构，显然可知string实质就是字符数组，但有一点区别就是，string可以扩容，再类比动态顺序表，就不难得出string的成员变量。在模拟实现string时，为了与C++标准库中的string作区分，可以给定命名空间。

成员变量：

  1. char* str：指向string第一个字符的指针。
  2. size_t size：string中有效数据的个数。
  3. size_t capacity：string可以存放有效数据的容量。
  4. static const size_t npos：静态成员。

大体结构如下：

  1. namespace xzy
  2. {classstring{private:char* _str =nullptr;
  3.         size_t _size =0;
  4.         size_t _capacity =0;staticconst size_t npos;//静态成员类内声明};const size_t string::npos =-1;//类外初始化}

二.构造函数

  1. classstring{public:string():_str(nullptr),_size(0),_capacity(0){}string(constchar* str):_size(strlen(str)),_capacity(_size),_str(newchar[_capacity +1]){}constchar*c_str()const{return _str;}private:char* _str;
  2.     size_t _size;
  3.     size_t _capacity;};

在这里插入图片描述
在这里插入图片描述

  1. 第一种由于将_str初始化为nullptr，通过C语言中的返回_str直到遇到’\0’停止打印字符串的方法，而_str为nullptr，打印nullptr导致程序崩溃。
  2. 第二种看似程序正常但真的是正确的吗？其实：初始化列表出现的顺序，并不是初始化的顺序，而是按照成员变量声明的顺序初始化成员变量，先初始化_str，而_capacity是随机值，导致开辟的空间不确定，导致出现错误。

正确的方法如下：

1.无参（默认）构造

 由于string默认含有’\0’，可以提前开辟一个’\0’，而’\0’不是有效的数据，也不算入容量之中。

  1. string():_str(newchar[1]{'\0'}),_size(0),_capacity(0){}

2.有参构造

 注意：容量中不包含’\0’，而string中有包含’\0’，所以在开辟空间时要加上一个’\0’的空间。

  1. string(constchar* str){
  2.     _size =strlen(str);
  3.     _capacity = _size;
  4.     _str =newchar[_capacity +1];strcpy(_str, str);}

3.兼容无参和有参构造

  1. string(constchar* str =""){
  2.     _size =strlen(str);
  3.     _capacity = _size;
  4.     _str =newchar[_capacity +1];strcpy(_str, str);}
  1. 不传参时：用缺省值，str为空的常量字符串，strlen(str)为0，且sizeof(str)为1，含有一个隐藏的’\0’，刚好满足无参构造。
  2. 传参时：就用实参，满足有参构造。

4.拷贝构造

  1. string(const string& str){
  2.     _str = str._str;
  3.     _size = str._size;
  4.     _capacity = str._capacity;}intmain(){
  5.     xzy::string s1;
  6.     xzy::string s2(s1);return0;}

在这里插入图片描述

分析：当我们未提供拷贝构造时，编译器会提供拷贝构造，进行简单的值拷贝（浅拷贝），正如以上代码。但是存在很大的漏洞，s1的_str与s2的_str指向堆区同一块空间，程序结束时分别调用各自的析构函数，从而对同一块空间释放两次，这是未定义行为，导致程序崩溃。

1.传统写法

思路：先开空间，再利用strcpy拷贝，最后修改有效数据大小与容量。

  1. string(const string& str){
  2.     _str =newchar[str._capacity +1];strcpy(_str, str._str);
  3.     _size = str._size;
  4.     _capacity = str._capacity;}

2.现代写法

构造一个临时对象，进行交换。

  1. voidswap(string& str){
  2.     std::swap(_str, str._str);
  3.     std::swap(_size, str._size);
  4.     std::swap(_capacity, str._capacity);}string(const string& str){
  5.     string tmp(str._str);swap(tmp);}

在这里插入图片描述

  1. 注意

：由于没有初始化列表，不确定s2_str被初始化为nullptr，取决于编译器，可以在类成员变量声明时加上缺省值，确保s2.str为nullptr，而避免s2._str为随机值，交换给tmp变成野指针，函数结束时tmp调用析构函数释放不合法的空间导致程序崩溃。

  1. classstring{private:char* _str =nullptr;
  2.     size_t _size =0;
  3.     size_t _capacity =0;};

三.析构函数

 _str是在堆区开辟的空间，要用delete[]释放空间，否则造成内存泄漏。

  1. ~string(){delete[] _str;
  2.     _str =nullptr;
  3.     _size = _capacity =0;}

四.string类对象的容量操作

1.size

  1. size_t size()const{return _size;}

2.capacity

  1. size_t capacity()const{return _capacity;}

3.clear

  1. voidclear(){
  2.     _str[0]='\0';
  3.     _size =0;}

4.empty

判断有效数据是否为0即可。

  1. boolempty(){return _size ==0;}

5.reserve

扩容时：先开辟新空间，千万记得多开一个空间保存’\0’，再将旧空间拷贝到空间，释放旧空间，修改_str指向新空间，最后修改容量。学了C++，new就取代realloc了。

  1. voidreserve(size_t n){if(n > _capacity){char* tmp =newchar[n +1];strcpy(tmp, _str);delete[] _str;
  2.         _str = tmp;
  3.         _capacity = n;}}

6.resize

修改有效数据的个数时：先比较修改后的有效数据与原有数据的大小，若小于则修改_size，若大于再比较容量与修改后的有效数据的大小，判断是否扩容，利用memset函数初始化。

  1. void string::resize(size_t n,char c){if(n > _size){// 如果newSize大于底层空间大小，则需要重新开辟空间if(n > _capacity){reserve(n);}memset(_str + _size, c, n - _size);}
  2.     _size = n;
  3.     _str[n]='\0';}

五.string类对象的访问及遍历操作

1.operator[]

  1. char&operator[](int pos){assert(pos >=0&& pos < _size);return _str[pos];}constchar&operator[](int pos)const{assert(pos >=0&& pos < _size);return _str[pos];}
  1. 提供两个版本的operator[]：普通重载[]与const修饰的重载[]。若初始化一个常量字符串时：const string s(“123”); 由于存在权放大问题，就无法调用普通重载[]，而const修饰的重载[]就可以使用。
  2. 重载operator[]，本质就是函数重载，而函数的返回值是不支持函数重载条件的，为了让两个operator[]满足函数重载的条件，可以const随便修饰一个成员函数。隐藏了this指针，实际const修饰的是this所指的对象。
  3. 第一个函数的参数列表的第一个位置隐藏了string* const this；第二个函数的参数列表的第一个位置隐藏了const string* const this；函数的参数不同就满足了函数重载的条件，可以共存。

2.实现迭代器：begin+end

  1. typedefchar* iterator;typedefconstchar* const_iterator;
  3. iterator begin(){return _str;}
  4. iterator end(){return _str + _size;}
  6. const_iterator begin()const{return _str;}
  7. const_iterator end()const{return _str + _size;}

为了与标准库里的类似，重定义char* 为iterator。同理提供两个版本的迭代器iterator与const_iterator。

六.string类对象的增删查改操作

1.operator=

注意：

  1. operator=只能写成成员函数

，不能写成成员函数。

1.传统写法

与传统写法的拷贝构造类似。

  1. string&operator=(const string& str){if(this!=&str){delete[] _str;
  2.         
  3.         _str =newchar[str._capacity +1];strcpy(_str, str._str);
  4.         _size = str._size;
  5.         _capacity = str._capacity;}return*this;}

注意：如果没写 if (this != &str) 自己给自己赋值时，delete[] _str 后_str为野指针，自己给自己拷贝程序崩溃。

2.现代写法

与现代写法的拷贝构造类似。

  1. string&operator=(const string& str){if(this!=&str){//string tmp(str.c_str()); //调用构造
  2.         string tmp(str);//调用拷贝构造swap(tmp);//刚好函数结束时，tmp将赋值前的空间释放，相当的完美}return*this;}//更完美的方法：一行搞定
  3. string&operator=(string tmp){swap(tmp);return*this;}

2.push_back

尾插时：先检查容量，再进行尾插。注意：

  1. 最后要补上'\0'

。

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

3.pop_back

尾删时：先检查是否有有效数据，有效数据自减一，在赋值’\0’。

  1. voidpop_back(){assert(!empty());--_size;
  2.     _str[size]='\0';}

4.append

追加时：先要判断容量是否大于有效数据+所追加的字符串大小。若小于则无需扩容；若大于两倍则需要多少就扩容多少；小于两倍就按照两倍扩容。最后拷贝字符串即可。

  1. voidappend(constchar* str){
  2.     size_t len =strlen(str);if(_size + len > _capacity){reserve(_size + len >2* _capacity ? _size + len :2* _capacity);}strcpy(_str + _size, str);
  3.     _size += len;}

5.operator+=

  1. +=一个字符：直接调用push_back即可。
  1. string&operator+=(char ch){push_back(ch);return*this;}
  1. +=一个字符串：直接调用append即可。
  1. string&operator+=(constchar* str){append(str);return*this;}

6.insert

  1. 插入一个字符：先检查容量，再整体往后挪动一位，最后插入即可。

但是存在一些坑如下：
在这里插入图片描述

  • 当在pos=0位置插入字符时：end=0时进入循环，- -end，由于end类型为无符号整形size_t，则end不是-1而是一个非常大的值，进入死循环。
  • 就算将end修改为int ，循环条件end>=pos时，两边类型不同会进行算数转换，int转换成size_t，end转换成size_t类型，依旧进入死循环。

正确写法：

  1. voidinsert(size_t pos,char ch){assert(pos >=0&& pos <= _size);if(_size == _capacity){reserve(_capacity ==0?4:2* _capacity);}//第一种：强转size_t为int//int end = _size;//while (end >= (int)pos)//{//      _str[end + 1] = _str[end];//      --end;//}//_str[pos] = ch;//++_size;//推荐这种：end始终大于0
  2.     size_t end = _size +1;while(end > pos){
  3.         _str[end]= _str[end -1];--end;}
  4.     _str[pos]= ch;++_size;}
  1. 插入一个字符串：先检查容量，再整体往后挪动为插入的字符串预留空间，最后插入字符串即可。
  1. voidinsert(size_t pos,constchar* str){assert(pos >=0&& pos <= _size);
  3.     size_t len =strlen(str);if(_size + len > _capacity){reserve(_size + len >2* _capacity ? _size + len :2* _capacity);}//整体后移//memmove(_str + len, _str, sizeof(char) * len);
  4.     size_t end = _size + len;while(end > pos + len -1){
  5.         _str[end]= _str[end - len];--end;}//插入字符串for(size_t i =0; i < len; i++){
  6.         _str[pos + i]= str[i];}
  7.     _size += len;}

7.erase

删除时：比较要删除的子串长度与pos及其以后字符串的的大小，判断是否pos及其以后得字符全删除。

  1. voiderase(size_t pos, size_t len = npos
  2. ){assert(pos >=0&& pos < _size);if(len >= _size - pos){
  3.         _str[pos]='\0';
  4.         _size = pos;}else{//memmove(_str + pos, _str + pos + len, sizeof(char) * (_size - pos - len + 1));for(size_t i = pos; i <= _size - len; i++){
  5.             _str[i]= _str[i + len];}
  6.         _size -= len;}}

8.find

  1. 查找字符：找到返回下标，未找到返回npos。
  1. size_t find(char ch, size_t pos =0){assert(pos >=0&& pos < _size);for(size_t i =0; i < _size; i++){if(_str[i]== ch){return i;}}return npos;}
  1. 查找字符串：利用C语言接口strstr查找子串函数，找到返回下标，未找到返回npos。
  1. size_t find(constchar* str, size_t pos =0){assert(pos >=0&& pos < _size);constchar* ptr =strstr(_str + pos, str);if(ptr ==nullptr){return npos;}else{return ptr - _str;}}

9.substr

返回子串：比较要返回子串长度与pos及其以后字符串的的大小，判断是否pos及其以后得字符全返回。

  1. 注意：深浅拷贝问题；

由于是返回局部string，而局部string出函数被销毁。此时会拷贝构造一个临时string作为返回，而默认的拷贝构造是浅拷贝（简单的值拷贝），局部string销毁时，临时变量string中的_str变成野指针，外面又拷贝构造接收该临时string，本身就是无效的string，程序结束前调用析构函数释放空间，重复的delete导致程序崩溃。

  1. 解决方法：自己写一个深拷贝构造。
  1. string substr(size_t pos =0, size_t len){assert(pos >=0&& pos < _size);if(len > _size - pos){
  2.         len = _size - pos;}
  4.     string sub;
  5.     sub.reserve(len);for(size_t i =0; i < len; i++){
  6.         sub += _str[pos + i];}return sub;}

10.c_str

返回字符串首字符的地址：用于调用C语言接口，例如strcpy，memmove等。

  1. constchar*c_str()const{return _str;}

11.swap

调用std::swap进行对象（值）交换。

  1. voidswap(string& str){
  2.     std::swap(_str, str._str);
  3.     std::swap(_size, str._size);
  4.     std::swap(_capacity, str._capacity);}

七.非成员函数

1.string比较函数

只需要利用strcmp函数比较，实现两个函数，就可以调用实现多个函数。

  1. booloperator<(const string& s1,const string& s2){returnstrcmp(s1.c_str(), s2.c_str())<0;}booloperator>(const string& s1,const string& s2){return!(s1 <= s2);}booloperator==(const string& s1,const string& s2){returnstrcmp(s1.c_str(), s2.c_str())==0;}booloperator<=(const string& s1,const string& s2){return s1 < s2 || s1 == s2;}booloperator>=(const string& s1,const string& s2){return!(s1 < s2);}booloperator!=(const string& s1,const string& s2){return!(s1 == s2);}

2.流插入与流提取

  在C++中，屏幕和键盘分别通过标准输出流（std::cout）和标准输入流（std::cin）来实现数据的流插入（输出）和流提取（输入）。以下是针对屏幕（输出）和键盘（输入）的流插入与流提取的详细介绍：

  1. 屏幕（输出）与流插入（operator<<）：流插入（operator<<）用于将数据发送到输出流中，在C++中，标准输出流std::cout是与屏幕（通常是控制台或命令行界面）相关联的。当你使用<<操作符将数据发送到std::cout时，数据会被格式化（如果需要的话）并显示在屏幕上。
  2. 键盘（输入）与流提取（operator>>）：流提取（operator>>）用于从输入流中读取数据，在C++中，标准输入流std::cin是与键盘（或任何标准输入设备）相关联的。当你使用>>操作符从std::cin中读取数据时，它会从键盘获取输入，并根据需要将其存储在提供的变量中。

注意：

  1. 流插入与流提取不推荐写成成员函数，例如ostream& operator<<(ostream& out); 因为<<左边是类对象，调用时要写成s<<out，非常别扭。
  2. 不需要写成友元函数，可以做到不用访问类内的私有成员，完成流插入与流提取。
  1. ostream&operator<<(ostream& out,const string& str){/*string::const_iterator it = str.begin();
  2.     while (it != str.end())
  3.     {
  4.         cout << *it;
  5.         ++it;
  6.     }*/for(auto ch : str){out<< ch;}return out;}
  7.     
  8. istream&operator>>(istream& in, string& str){
  9.     str.clear();char ch;//in >> ch; //错误，ch不会提取空白字符，陷入死循环
  10.     ch = in.get();while(ch !=' '&& ch !='\n'){
  11.         str += ch;//in >> ch;
  12.         ch = in.get();}return in;}

注意：

  1. 流提取cin默认跳过空白字符（不会读取空白字符）

，例如：空格、换行，可以用

  1. cin.get()

函数从键盘获得空白字符，类似C语言中的getc()函数。

  1. 优化方法

：减少扩容，临时存放到字符数组中，等到满了时，再+=到其中。

  1. istream&operator>>(istream& in, string& str){
  2.     str.clear();constint N =256;char buff[N];int i =0;char ch;
  3.     ch = in.get();while(ch !=' '&& ch !='\n'){
  4.         buff[i++]= ch;if(i == N -1){
  5.             buff[i]='\0';
  6.             str += buff;
  7.             i =0;}
  8.         ch = in.get();}if(i >0){
  9.         buff[i]='\0';
  10.         str += buff;}return in;}

3.getline

getline函数：可以读取含有空格的字符串，将’\n’作为分隔符。

  1. istream&getline(istream& in, string& str){
  2.     str.clear();char ch;
  3.     ch = in.get();while(ch !='\n'){
  4.         str += ch;
  5.         ch = in.get();}return in;}

八.深浅拷贝问题

1.浅拷贝

  1. 浅拷贝

：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致
多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该
资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。

在这里插入图片描述
可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。

2.深拷贝

在这里插入图片描述

3.引用计数+写时拷贝

  1. 当浅拷贝时存在两个问题：析构多次+一个修改影响另一个。
  2. 引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。
  3. 写时拷贝：当需要修改其中一个对象的指针时，为了不影响其它对象，使用深拷贝。

九.源代码

1.string.h

  1. //#pragma once#ifndef__STRING_H__#define__STRING_H__#include<iostream>#include<assert.h>usingnamespace std;namespace xzy
  2. {classstring{public:typedefchar* iterator;typedefconstchar* const_iterator;
  4.         iterator begin(){return _str;}
  6.         iterator end(){return _str + _size;}
  8.         const_iterator begin()const{return _str;}
  10.         const_iterator end()const{return _str + _size;}//短小频繁调用的函数，可以直接定义到类里面，默认是inlinestring(constchar* str =""){
  11.             _size =strlen(str);
  12.             _capacity = _size;
  13.             _str =newchar[_capacity +1];strcpy(_str, str);}voidswap(string& str){
  14.             std::swap(_str, str._str);
  15.             std::swap(_size, str._size);
  16.             std::swap(_capacity, str._capacity);}string(const string& str){
  17.             string tmp(str._str);swap(tmp);}//s2 = s1/*string& operator=(const string& str)
  18.         {
  19.             if (this != &str)
  20.             {
  21.                 delete[] _str;
  23.                 _str = new char[str._capacity + 1];
  24.                 strcpy(_str, str._str);
  25.                 _size = str._size;
  26.                 _capacity = str._capacity;
  27.             }
  28.             return *this;
  29.         }*/
  31.         string&operator=(string tmp){swap(tmp);return*this;}
  33.         string&operator=(const string& str){if(this!=&str){
  34.                 string tmp(str.c_str());swap(tmp);}return*this;}~string(){delete[] _str;
  35.             _str =nullptr;
  36.             _size = _capacity =0;}constchar*c_str()const{return _str;}voidclear(){
  37.             _str[0]='\0';
  38.             _size =0;}
  40.         size_t size()const{return _size;}
  42.         size_t capacity()const{return _capacity;}char&operator[](int pos){assert(pos >=0&& pos < _size);return _str[pos];}constchar&operator[](int pos)const{assert(pos >=0&& pos < _size);return _str[pos];}voidresize(size_t n,char c ='\0');voidreserve(size_t n);voidpush_back(char ch);voidappend(constchar* str);
  43.         string&operator+=(char ch); 
  44.         string&operator+=(constchar* str);voidinsert(size_t pos,char ch);voidinsert(size_t pos,constchar* str);voiderase(size_t pos, size_t len = npos);
  46.         size_t find(char ch, size_t pos =0);
  47.         size_t find(constchar* str, size_t pos =0);
  48.         string substr(size_t pos =0, size_t len = npos);private:char* _str =nullptr;
  49.         size_t _size =0;
  50.         size_t _capacity =0;staticconst size_t npos;};booloperator<(const string& s1,const string& s2);booloperator>(const string& s1,const string& s2);booloperator==(const string& s1,const string& s2);booloperator<=(const string& s1,const string& s2);booloperator>=(const string& s1,const string& s2);booloperator!=(const string& s1,const string& s2);
  52.     ostream&operator<<(ostream& out,const string& str);
  53.     istream&operator>>(istream& in, string& str);
  54.     istream&getline(istream& in, string& str);voidtest_string1();voidtest_string2();voidtest_string3();voidtest_string4();}#endif

2.string.cpp

  1. #define_CRT_SECURE_NO_WARNINGS1#include"string.h"namespace xzy
  2. {const size_t string::npos =-1;void string::resize(size_t n,char c){if(n > _size){// 如果newSize大于底层空间大小，则需要重新开辟空间if(n > _capacity){reserve(n);}memset(_str + _size, c, n - _size);}
  3.         _size = n;
  4.         _str[n]='\0';}void string::reserve(size_t n){if(n > _capacity){char* tmp =newchar[n +1];strcpy(tmp, _str);delete[] _str;
  5.             _str = tmp;
  6.             _capacity = n;}}void string::push_back(char ch){if(_size == _capacity){reserve(_capacity ==0?4:2* _capacity);}
  7.         _str[_size]= ch;++_size;
  8.         _str[_size]='\0';}void string::append(constchar* str){
  9.         size_t len =strlen(str);if(_size + len > _capacity){reserve(_size + len >2* _capacity ? _size + len :2* _capacity);}strcpy(_str + _size, str);
  10.         _size += len;}
  12.     string& string::operator+=(char ch){push_back(ch);return*this;}
  14.     string& string::operator+=(constchar* str){append(str);return*this;}void string::insert(size_t pos,char ch){assert(pos >=0&& pos <= _size);if(_size == _capacity){reserve(_capacity ==0?4:2* _capacity);}/*int end = _size;
  15.         while (end >= (int)pos)
  16.         {
  17.             _str[end + 1] = _str[end];
  18.             --end;
  19.         }
  20.         _str[pos] = ch;
  21.         ++_size;*/
  23.         size_t end = _size +1;while(end > pos){
  24.             _str[end]= _str[end -1];--end;}
  25.         _str[pos]= ch;++_size;}void string::insert(size_t pos,constchar* str){assert(pos >=0&& pos <= _size);
  27.         size_t len =strlen(str);if(_size + len > _capacity){reserve(_size + len >2* _capacity ? _size + len :2* _capacity);}//memmove(_str + len, _str, sizeof(char) * len);
  28.         size_t end = _size + len;while(end > pos + len -1){
  29.             _str[end]= _str[end - len];--end;}for(size_t i =0; i < len; i++){
  30.             _str[pos + i]= str[i];}
  31.         _size += len;}void string::erase(size_t pos, size_t len){assert(pos >=0&& pos < _size);if(len >= _size - pos){
  32.             _str[pos]='\0';
  33.             _size = pos;}else{//memmove(_str + pos, _str + pos + len, sizeof(char) * (_size - pos - len + 1));for(size_t i = pos; i <= _size - len; i++){
  34.                 _str[i]= _str[i + len];}
  35.             _size -= len;}}
  37.     size_t string::find(char ch, size_t pos){assert(pos >=0&& pos < _size);for(size_t i =0; i < _size; i++){if(_str[i]== ch){return i;}}return npos;}
  39.     size_t string::find(constchar* str, size_t pos){assert(pos >=0&& pos < _size);constchar* ptr =strstr(_str + pos, str);if(ptr ==nullptr){return npos;}else{return ptr - _str;}}
  41.     string string::substr(size_t pos, size_t len){assert(pos >=0&& pos < _size);if(len > _size - pos){
  42.             len = _size - pos;}
  44.         string sub;
  45.         sub.reserve(len);for(size_t i =0; i < len; i++){
  46.             sub += _str[pos + i];}return sub;}booloperator<(const string& s1,const string& s2){returnstrcmp(s1.c_str(), s2.c_str())<0;}booloperator>(const string& s1,const string& s2){return!(s1 <= s2);}booloperator==(const string& s1,const string& s2){returnstrcmp(s1.c_str(), s2.c_str())==0;}booloperator<=(const string& s1,const string& s2){return s1 < s2 || s1 == s2;}booloperator>=(const string& s1,const string& s2){return!(s1 < s2);}booloperator!=(const string& s1,const string& s2){return!(s1 == s2);}
  48.     ostream&operator<<(ostream& out,const string& str){/*string::const_iterator it = str.begin();
  49.         while (it != str.end())
  50.         {
  51.             cout << *it;
  52.             ++it;
  53.         }*/for(auto ch : str){out<< ch;}return out;}
  55.     istream&operator>>(istream& in, string& str){
  56.         str.clear();constint N =256;char buff[N];int i =0;char ch;
  57.         ch = in.get();while(ch !=' '&& ch !='\n'){
  58.             buff[i++]= ch;if(i == N -1){
  59.                 buff[i]='\0';
  60.                 str += buff;
  61.                 i =0;}
  62.             ch = in.get();}if(i >0){
  63.             buff[i]='\0';
  64.             str += buff;}return in;}
  66.     istream&getline(istream& in, string& str){
  67.         str.clear();char ch;
  68.         ch = in.get();while(ch !='\n'){
  69.             str += ch;
  70.             ch = in.get();}return in;}}
标签： c++ java android
本文转载自: https://blog.csdn.net/2203_76003626/article/details/140750046
版权归原作者 清风~徐~来 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【C++标准库】模拟实现string+深浅拷贝问题”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？