襄阳的网站建设公司,apache多个网站,网站建设报价费用是多少,微信网站后期运营怎么做string类
string不属于STL,早于STL出现
看文档 C非官网(建议用这个) C官网 文章目录 string类一.为什么学习string类#xff1f;1.C语言中的字符串2. 两个面试题(暂不做讲解) 二.标准库中的string类1. string类(了解)2. string类的常用接口说明#xff08;注意下面我只讲解…string类
string不属于STL,早于STL出现
看文档 C非官网(建议用这个) C官网 文章目录 string类一.为什么学习string类1.C语言中的字符串2. 两个面试题(暂不做讲解) 二.标准库中的string类1. string类(了解)2. string类的常用接口说明注意下面我只讲解最常用的接口(1).string类对象的常见构造(2).string类对象的容量操作(3).string类对象的访问及遍历操作(4).string类对象的修改操作(5).string类非成员函数(6). vs和g下string结构的说明(7).牛刀小试 三.string类的模拟实现1. 浅拷贝2. 深拷贝3. 模拟实现String类4. 写时拷贝(了解) 四. 扩展阅读五.补充知识 一.为什么学习string类
1.C语言中的字符串
C语言中字符串是以’\0’结尾的一些字符的集合为了操作方便C标准库中提供了一些str系列的库函数但是这些库函数与字符串是分离开的不太符合OOP的思想而且底层空间需要用户自己管理稍不留神可能还会越界访问。
2. 两个面试题(暂不做讲解)
字符串相加 在OJ中有关字符串的题目基本以string类的形式出现而且在常规工作中为了简单、方便、快捷基本都使用string类很少有人去使用C库中的字符串操作函数。
二.标准库中的string类
1. string类(了解) string类的文档介绍 字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持其接口类似于标准字符容器的接口但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型使用它的默认char_traits和分配器类型(关于模板的更多信息请参阅basic_string)。string类是basic_string模板类的一个实例它使用char来实例化basic_string模板类并用char_traits和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。注意这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列这个类的所有成员(如长度或大小)以及它的迭代器将仍然按照字节(而不是实际编码的字符)来操作。 总结 string是表示字符串的字符串类该类的接口与常规容器的接口基本相同再添加了一些专门用来操作string的常规操作。string在底层实际是basic_string模板类的别名typedef basic_stringchar, char_traits, allocator string;不能操作多字节或者变长字符的序列。 在使用string类时必须包含#include头文件以及using namespace std; 2. string类的常用接口说明注意下面我只讲解最常用的接口
(1).string类对象的常见构造 void Teststring()
{string s1; // 构造空的string类对象s1string s2(hello bit); // 用C格式字符串构造string类对象s2string s3(s2); // 拷贝构造s3
}(2).string类对象的容量操作 [string容量相关方法使用代码演示](课件代码/C课件V6/string的接口测试及使用/TestString.cpp · will/C上课 - Gitee.com) 注意 size()与length()方法底层实现原理完全相同引入size()的原因是为了与其他容器的接口保持一致一般情况下基本都是用size()有效字符长度不包含’/0’(/0’是标识字符,不是有效字符)。 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_arg0)为string预留空间不改变有效元素个数当reserve的参数小于string的底层空间总大小时reserver不会改变容量大小。 补充①:扩容 补充②:静态分配和动态分配 补充③:清除和缩容 补充④:reverse
(3).string类对象的访问及遍历操作 补充知识:迭代器
[string中元素访问及遍历代码演示](课件代码/C课件V6/string的接口测试及使用/TestString.cpp · will/C上课 - Gitee.com)
(4).string类对象的修改操作 [string中插入和查找等使用代码演示](课件代码/C课件V6/string的接口测试及使用/TestString.cpp · will/C上课 - Gitee.com) 注意 在string尾部追加字符时s.push_back© / s.append(1, c) / s c’三种的实现方式差不多一般情况下string类的操作用的比较多操作不仅可以连接单个字符还可以连接字符串。对string操作时如果能够大概预估到放多少字符可以先通过reserve把空间预留好。 (5).string类非成员函数 cinstr遇到空格停止,getline不会
上面的几个接口大家了解一下下面的OJ题目中会有一些体现他们的使用。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 onevalue_type _Buf[_BUF_SIZE];pointer _Ptr;char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;这种设计也是有一定道理的大多数情况下字符串的长度都小于16那string对象创建好之后内部已经有了16个字符数组的固定空间不需要通过堆创建效率高。
其次还有一个size_t字段保存字符串长度一个size_t字段保存从堆上开辟空间总的容量
最后还有一个指针做一些其他事情。
故总共占1644428个字节。 g下string的结构 G下string是通过写时拷贝实现的string对象总共占4个字节内部只包含了一个指针该指针将来指向一块堆空间内部包含了如下字段 空间总大小 字符串有效长度 引用计数 struct _Rep_base
{size_type _M_length;size_type _M_capacity;_Atomic_word _M_refcount;
};指向堆空间的指针用来存储字符串。
引用计数举例: (7).牛刀小试
仅仅反转字母
class Solution {
public:string reverseOnlyLetters(string s) {int left0;int rights.size()-1;while(leftright){while(leftright !isalpha(s[left])){left;}while(leftright !isalpha(s[right])){right--;}swap(s[left],s[right]);left;right--;}return s;}
};找字符串中第一个只出现一次的字符
class Solution {
public:int firstUniqChar(string s) {int count[26]{0};char ch;size_t n;for(auto c : s){count[c-a];}for(auto c : s){if(count[c-a]1){chc;ns.find(ch);return n;}}return -1;}
};字符串里面最后一个单词的长度
#include iostream
#include string
using namespace std;int main()
{string str;// 不能用cinstr遇到空格就结束了getline(cin, str);size_t nstr.rfind( );if(n!string::npos){cout(str.size()-n-1);}else {coutstr.size();}return 0;
}验证一个字符串是否是回文
class Solution {
public:bool isPalindrome(string s) {string str;string rstr;char c;for(int i0;is.size();i){if((s[i]as[i]z)||(s[i]0s[i]9)){strs[i];}else if(s[i]As[i]Z){ctolower(s[i]);strc;}}if(s.empty())return true;rstrstr;reverse(rstr.begin(),rstr.end());if(str.compare(rstr)0){return true;}return false;}
};字符串相加
class Solution {
public:string addStrings(string num1, string num2) {int end1num1.size()-1,end2num2.size()-1;// 进位int next0;string retstr;while(end10 || end20){int val1end10?num1[end1--]-0:0;int val2end20?num2[end2--]-0:0;int retval1val2next;nextret/10;retret%10;//retstr.insert(0 , 1 , ret0);retstr.push_back(ret0);}if(next1){//retstr.insert(0 , 1 , 1);retstr.push_back(1);}reverse(retstr.begin(),retstr.end());return retstr;}
};翻转字符串II区间部分翻转 class Solution {
public:string reverseStr(string s, int k){int n s.size();int pos 0;if (s.size() k){reverse(s.begin(), s.end());return s;}if (s.size() 2 * k s.size() k){reverse(s.begin(), s.begin() k);return s;}while (n 2 * k){reverse(s.begin() pos, s.begin() pos k);pos 2 * k;n - 2 * k;}if (n k){reverse(s.begin() pos, s.end());return s;}if (n 2 * k n k){reverse(s.begin() pos, s.begin() pos k);return s;}return s;}
};转字符串III翻转字符串中的单词 class Solution {
public:string reverseWords(string s) {int pos0;int ns.find( , pos);if(nstring::npos){reverse(s.begin(),s.end());return s;}else{reverse(s.begin(),s.begin()n);posn1;ns.find( , pos);}while(n!string::npos){reverse(s.begin()pos,s.begin()n);posn1;ns.find( , pos); }if(nstring::npos){reverse(s.begin()pos,s.end());}return s;}
};符串相乘 class Solution {
public:string addStrings(string num1, string num2) {int end1num1.size()-1,end2num2.size()-1;// 进位int next0;string retstr;while(end10 || end20){int val1end10?num1[end1--]-0:0;int val2end20?num2[end2--]-0:0;int retval1val2next;nextret/10;retret%10;//retstr.insert(0 , 1 , ret0);retstr.push_back(ret0);}if(next1){//retstr.insert(0 , 1 , 1);retstr.push_back(1);}reverse(retstr.begin(),retstr.end());return retstr;}string multiply(string num1, string num2) {string ret0;int n num2.size();if (num1 0 || num2 0)return 0;for (int i n - 1; i 0; i--){string tmp;string sum;int t num2[i]-0;while (t 0){tmp addStrings(tmp, num1);sum tmp;--t;}int j n - i - 1;if(j 0){int k pow(10,j);while (k 1){sum addStrings(sum, tmp);--k;}}ret addStrings(ret, sum);}return ret;
}
};找出字符串中第一个只出现一次的字符 string类的模拟实现}}cout-1;return;
}int main() {string s;getline(cin,s);firstUniqChar(s);}
// 64 位输出请用 printf(%lld)三.string类的模拟实现
1. 浅拷贝
浅拷贝也称位拷贝编译器只是将对象中的值拷贝过来。如果对象中管理资源最后就会导致多个对象共享同一份资源当一个对象销毁时就会将该资源释放掉而此时另一些对象不知道该资源已经被释放以为还有效所以当继续对资源进项操作时就会发生发生了访问违规。
就像一个家庭中有两个孩子但父母只买了一份玩具两个孩子愿意一块玩则万事大吉万一不想分享就你争我夺玩具损坏。 可以采用深拷贝解决浅拷贝问题即每个对象都有一份独立的资源不要和其他对象共享。
2. 深拷贝
如果一个类中涉及到资源的管理其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。 3. 模拟实现String类
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#includeiostream
#includestring.h
#includeassert.hnamespace bit
{class string{public:typedef char* iterator;typedef const char* const_iterator;const_iterator begin() const{return _str;}const_iterator end() const{return _str _size;}iterator begin(){return _str;}iterator end(){return _str _size;}const char* c_str()const{return _str;}string(const char* str):_size(strlen(str)){_capacity_size;_strnew char[_capacity1];strcpy(_str, str);}// 1.现代写法string(const string s){string tmp(s._str);swap(tmp);}// 2.传统写法//string(const string s)//{// _str new char[s._capacity1];// strcpy(_str, s._str);// _size s._size;// _capacity s._capacity;//}// 1.现代写法string operator(string tmp){swap(tmp);return *this;}// 2.传统写法//string operator(const string s)//{// char* tmp new char[s._capacity 1];// strcpy(tmp, s._str);// delete[] _str;// _str tmp;// _size s._size;// _capacity s._capacity;// return *this;//}~string(){delete[] _str;_str nullptr;_size _capacity 0;}size_t size()const{return _size;}size_t capacity()const{return _capacity;}char operator[](int pos){assert(pos _size);return _str[pos];}const char operator[](int pos)const{assert(pos _size);return _str[pos];}// 1. 自己版本void resize(size_t n, char ch \0){if (n _size){_str[n] \0;_size n;}else{for (int i n; i _size; i--){push_back(\0);}_size n;}}// 2. 老师版本//void resize(size_t n, char ch \0)//{// if (n _size)// {// _str[n] \0;// _size n;// }// else// {// reserve(n);// for (size_t i _size; i n; i)// {// _str[i] ch;// }// _str[n] \0;// _size n;// }//}void reserve(size_t n){if (n _capacity){char* tmp new char[n1];strcpy(tmp, _str);delete[] _str;_str tmp;_capacity n;}}//优化版本void push_back(char ch){insert(_size, ch);}// 原始版本//void push_back(char ch)//{// // 扩容2倍// if (_size _capacity)// {// reserve(_capacity0?4:2 * _capacity);// }// _str[_size] ch;// _str[_size] \0;//}//优化版本void append(const char* str){insert(_size, str);}// 原始版本//void append(const char* str)//{// // 扩容// size_t len strlen(str);// if (_size len _capacity)// {// reserve(_size len);// }// //strcat(_str, str);需要找_str结尾效率低// strcpy(_str _size, str);// _size len;//}string operator(char ch){push_back(ch);return *this;}string operator(const char* str){append(str);return *this;}// 1.老师版本void insert(size_t pos, char ch){assert(pos _size);// 扩容2倍if (_size _capacity){reserve(_capacity 0 ? 4 : 2 * _capacity);}//这种写法:// 1.end 不能用size_t类型,如果pos0 , end减到0后会死循环// 2.必须强转pos为int,否则-1pos(-1是size_t中最大值)/*int end _size;while (end (int)pos){_str[end 1] _str[end];--end;}*/size_t end _size 1;while (end pos){_str[end] _str[end - 1];--end;}_str[pos] ch;_size;}// 2.自己版本//void insert(size_t pos, char ch)//{// assert(pos _size);// if (_size _capacity)// {// reserve(_capacity 0 ? 4 : 2 * _capacity);// }// char* tmp new char[_capacity];// strcpy(tmp, _str pos - 1);// strcpy(_str pos, tmp);// _str[pos] ch;// _size;//}// 1.老师版本void insert(size_t pos, const char* str){assert(pos _size);// 扩容size_t len strlen(str);if (_size len _capacity){reserve(_size len);}size_t end _size len;while (end pos len - 1){_str[end] _str[end - len];--end;}strncpy(_str pos, str, len);_size len;}// 2.自己版本//void insert(size_t pos, const char* str)//{// assert(pos _size);// size_t len strlen(str);// if (_sizelen _capacity)// {// reserve(_size len);// }// char* tmp new char[_capacity];// strcpy(tmp, _str pos);// strcpy(_str pos, str);// strcpy(_str pos len, tmp);// _size len;//}void erase(size_t pos, size_t len npos){assert(pos _size);if (len npos || len _size - pos)//不能写len pos _size ,左边有溢出风险{_str[pos] \0;_size pos;}else{strcpy(_str pos, _str pos len);_size - len;}}void swap(string s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}size_t find(char ch,size_t pos0)const{assert(pos _size);for (size_t i pos; i _size; i){if (_str[i] ch)return i;}return npos;}size_t find(char* sub, size_t pos 0)const{assert(pos _size);const char* p strstr(_str pos, sub);if (p){return p - _str;}else{return npos;}}// 1. 老师版本string substr(size_t pos 0, size_t len npos){string sub;//if (len npos || len _size-pos)if (len _size - pos){for (size_t i pos; i _size; i){sub _str[i];}}else{for (size_t i pos; i pos len; i){sub _str[i];}}return sub;}// 2. 自己版本//string substr(size_t pos0, size_t len npos)//{// string s;// if (len npos || len _size - pos)// {// s.reserve(_size - pos1);// strncpy(s._str, _str pos, _size - pos);// s._size _size - pos;// s \0;// }// else// {// s.reserve(len1);// strncpy(s._str, _str pos, len);// s._size len;// s \0;// }// return s;//}void clear(){_size 0;_str[_size] \0;}private:char* _strnullptr;size_t _size0;size_t _capacity0;public:static const int npos;};const int string::npos -1;void swap(string x, string y){x.swap(y);}bool operator(const string s1,const string s2){int ret strcmp(s1.c_str(), s2.c_str());return ret 0;}bool operator(const string s1, const string s2){int ret strcmp(s1.c_str(), s2.c_str());return ret 0;}bool operator(const string s1, const string s2){return s1s2||s1s2;}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 !(s1 s2);}std::ostream operator(std::ostream out, const string s){for (auto ch : s){out ch;}return out;}//优化版本std::istream operator(std::istream in, string s){s.clear();char ch;//in ch;//这种写法不行//c的cin和c语言的scanf读字符时取不到空格或者换号//把空格或者换号默认为分隔符, 默认忽略掉.// 解决办法://1.c语言用getchar或者getc//2.c用istream类里面的get// 注意: //c不能用c语言的办法, c语言和c的io流不是同一个, 它们各自有各自的缓冲区.(c会做兼容, 但是还是不要用getchr)ch in.get();char buff[128];//比s.reserve(128)好:1. 栈上开空间比堆上更快一些, 2.buff是局部变量不会一直占用空间size_t i 0;while (ch ! \n ch ! ){buff[i] ch;if (i 127){s[127] \0;s buff;//省的总是扩容,提高效率i 0;}ch in.get();}if (i 0){buff[i] \0;s buff;}return in;}//原始版本//std::istream operator(std::istream in, string s)//{// s.clear();// char ch;// //in ch;// //这种写法不行// //c的cin和c语言的scanf读字符时取不到空格或者换号// //把空格或者换号默认为分隔符, 默认忽略掉.// // 解决办法:// //1.c语言用getchar或者getc// //2.c用istream类里面的get// // 注意: // //c不能用c语言的办法, c语言和c的io流不是同一个, 它们各自有各自的缓冲区.(c会做兼容, 但是还是不要用getchr)// ch in.get();// while (ch ! \n ch ! )// {// s ch;//总是扩容,提高效率// ch in.get();// }// return in;//}//优化版本std::istream getline(std::istream in, string s){s.clear();char ch;ch in.get();char buff[128];size_t i 0;while (ch ! \n){buff[i] ch;if (i 127){buff[127] \0;s buff;i 0;}ch in.get();}if (i 0){buff[i] \0;s buff;}return in;}//原始版本//std::istream getline(std::istream in, string s)//{// s.clear();// char ch;// ch in.get();// while (ch ! \n)// {// s ch;// ch in.get();// }// return in;//}
}string模拟实现参考
4. 写时拷贝(了解)
写时拷贝就是一种拖延症是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数用来记录资源使用者的个数。在构造时将资源的计数给成1每增加一个对象使用该资源就给计数增加1当某个对象被销毁时先给该计数减1然后再检查是否需要释放资源如果计数为1说明该对象时资源的最后一个使用者将该资源释放否则就不能释放因为还有其他对象在使用该资源。
写时拷贝
写时拷贝在读取是的缺陷
四. 扩展阅读
面试中string的一种正确写法 STL中的string类怎么了
五.补充知识 问题: c的cin和c语言的scanf读字符时取不到空格或者换号。把空格或者换号默认为分隔符, 默认忽略掉。 解决办法: 1.c语言用getchar或者getc 2.c用istream类里面的get 注意: c不能用c语言的办法, c语言和c的io流不是同一个, 它们各自有各自的缓冲区.(c会做兼容, 但是还是不要用getchr)
