精华内容
下载资源
问答
  • 2020-07-18 10:22:36

    因为当前引用的库(< iostream >)已经隐式地包含了string头文件,所以无需显式引用该头文件也能够使用string。

    iostream 用到 ios_base这个类,而它的成员函数 ios_base::getloc 返回一个 std::locale类型 , 然后std::locale的成员函数 locale::name 又返回std::string类型,所以就需要string类型的定义。

    不过,并不建议依赖于这类隐式引用,如果没有显式地引用似乎会引发一些问题

    参考:
    C++ 使用字符串一定要 #include 吗?

    Do I have to use #include beside ?

    更多相关内容
  • mingw to_string()头文件

    2018-11-05 15:53:58
    补充mingw c++11下部分实现 (to_tring) 包括 wchar.h stdio.h
  • c++ string头文件详解

    万次阅读 多人点赞 2018-11-15 12:44:02
    标准c++中string类函数介绍 注意不是CString 之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必 担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作函数...

    标准c++中string类函数介绍

    注意不是CString
    之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必 担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作,== 进行比较,+ 做串联(是不是很简单?)。我们尽可以把它看成是C++的基本数据类型。

    好了,进入正题………
    首先,为了在我们的程序中使用string类型,我们必须包含头文件 <string>。

    如下:
    #include <string> //注意这里不是string.h string.h是C字符串头文件
    #include <string>
    using namespace std;

    1.声明一个C++字符串


    声明一个字符串变量很简单:
    string Str;
    这样我们就声明了一个字符串变量,但既然是一个类,就有构造函数和析构函数。上面的声明没有传入参数,所以就直接使用了string的默认的构造函数,这个函数所作的就是把Str初始化为一个空字符串。String类的构造函数和析构函数如下:
    a)      string s;    //生成一个空字符串s
    b)      string s(str) //拷贝构造函数 生成str的复制品
    c)      string s(str,stridx) //将字符串str内“始于位置stridx”的部分当作字符串的初值
    d)      string s(str,stridx,strlen) //将字符串str内“始于stridx且长度顶多strlen”的部分作为字符串的初值
    e)      string s(cstr) //将C字符串作为s的初值
    f)      string s(chars,chars_len) //将C字符串前chars_len个字符作为字符串s的初值。
    g)      string s(num,c) //生成一个字符串,包含num个c字符
    h)      string s(beg,end) //以区间beg;end(不包含end)内的字符作为字符串s的初值
    i)      s.~string() //销毁所有字符,释放内存
    都很简单,我就不解释了。

    2.字符串操作函数


    这里是C++字符串的重点,我先把各种操作函数罗列出来,不喜欢把所有函数都看完的人可以在这里找自己喜欢的函数,再到后面看他的详细解释。
    a) =,assign()     //赋以新值
    b) swap()     //交换两个字符串的内容
    c) +=,append(),push_back() //在尾部添加字符
    d) insert() //插入字符
    e) erase() //删除字符
    f) clear() //删除全部字符
    g) replace() //替换字符
    h) + //串联字符串
    i) ==,!=,<,<=,>,>=,compare()    //比较字符串
    j) size(),length()    //返回字符数量
    k) max_size() //返回字符的可能最大个数
    l) empty()    //判断字符串是否为空
    m) capacity() //返回重新分配之前的字符容量
    n) reserve() //保留一定量内存以容纳一定数量的字符
    o) [ ], at() //存取单一字符
    p) >>,getline() //从stream读取某值
    q) <<    //将谋值写入stream
    r) copy() //将某值赋值为一个C_string
    s) c_str() //将内容以C_string返回
    t) data() //将内容以字符数组形式返回
    u) substr() //返回某个子字符串
    v)查找函数
    w)begin() end() //提供类似STL的迭代器支持
    x) rbegin() rend() //逆向迭代器
    y) get_allocator() //返回配置器

    下面详细介绍:

    2.1 C++字符串和C字符串的转换


    C ++提供的由C++字符串得到对应的C_string的方法是使用data()、c_str()和copy(),其中,data()以字符数组的形式返回字符串内容,但并不添加'/0'。c_str()返回一个以‘/0'结尾的字符数组,而copy()则把字符串的内容复制或写入既有的c_string或 字符数组内。C++字符串并不以'/0'结尾。我的建议是在程序中能使用C++字符串就使用,除非万不得已不选用c_string。由于只是简单介绍,详细介绍掠过,谁想进一步了解使用中的注意事项可以给我留言(到我的收件箱)。我详细解释。

    2.2 大小和容量函数


    一个C++字符串存在三种大小:a)现有的字符数,函数是size()和length(),他们等效。Empty()用来检查字符串是否为空。b)max_size() 这个大小是指当前C++字符串最多能包含的字符数,很可能和机器本身的限制或者字符串所在位置连续内存的大小有关系。我们一般情况下不用关心他,应该大小足够我们用的。但是不够用的话,会抛出length_error异常c)capacity()重新分配内存之前 string所能包含的最大字符数。这里另一个需要指出的是reserve()函数,这个函数为string重新分配内存。重新分配的大小由其参数决定, 默认参数为0,这时候会对string进行非强制性缩减。

    还有必要再重复一下C++字符串和C字符串转换的问 题,许多人会遇到这样的问题,自己做的程序要调用别人的函数、类什么的(比如数据库连接函数Connect(char*,char*)),但别人的函数参 数用的是char*形式的,而我们知道,c_str()、data()返回的字符数组由该字符串拥有,所以是一种const char*,要想作为上面提及的函数的参数,还必须拷贝到一个char*,而我们的原则是能不使用C字符串就不使用。那么,这时候我们的处理方式是:如果 此函数对参数(也就是char*)的内容不修改的话,我们可以这样Connect((char*)UserID.c_str(), (char*)PassWD.c_str()),但是这时候是存在危险的,因为这样转换后的字符串其实是可以修改的(有兴趣地可以自己试一试),所以我强调除非函数调用的时候不对参数进行修改,否则必须拷贝到一个char*上去。当然,更稳妥的办法是无论什么情况都拷贝到一个char*上去。同时我们也祈祷现在仍然使用C字符串进行编程的高手们(说他们是高手一点儿也不为过,也许在我们还穿开裆裤的时候他们就开始编程了,哈哈…)写的函数都比较规范,那样我们就不必进行强制转换了。

    2.3元素存取


    我们可以使用下标操作符[]和函数at()对元素包含的字符进行访问。但是应该注意的是操作符[]并不检查索引是否有效(有效索引0~str.length()),如果索引失效,会引起未定义的行为。而at()会检查,如果使用 at()的时候索引无效,会抛出out_of_range异常。

    有一个例外不得不说,const string a;的操作符[]对索引值是a.length()仍然有效,其返回值是'/0'。其他的各种情况,a.length()索引都是无效的。举例如下:
    const string Cstr(“const string”);
    string Str(“string”);
    Str[3];      //ok
    Str.at(3);    //ok
    Str[100]; //未定义的行为
    Str.at(100);    //throw out_of_range
    Str[Str.length()]    //未定义行为
    Cstr[Cstr.length()] //返回 ‘/0'
    Str.at(Str.length());//throw out_of_range
    Cstr.at(Cstr.length()) throw out_of_range
    我不赞成类似于下面的引用或指针赋值:
    char& r=s[2];
    char* p= &s[3];
    因为一旦发生重新分配,r,p立即失效。避免的方法就是不使用。

    2.4比较函数


    C ++字符串支持常见的比较操作符(>,>=,<,<=,==,!=),甚至支持string与C-string的比较(如 str<”hello”)。在使用>,>=,<,<=这些操作符的时候是根据“当前字符特性”将字符按字典顺序进行逐一得 比较。字典排序靠前的字符小,比较的顺序是从前向后比较,遇到不相等的字符就按这个位置上的两个字符的比较结果确定两个字符串的大小。同时,string (“aaaa”) <string(aaaaa)。

    另一个功能强大的比较函数是成员函数compare()。他支持多参数处理,支持用索引值和长度定位子串来进行比较。他返回一个整数来表示比较结果,返回值意义如下:0-相等 〉0-大于 <0-小于。举例如下:
    string s(“abcd”);
    s.compare(“abcd”); //返回0
    s.compare(“dcba”); //返回一个小于0的值
    s.compare(“ab”); //返回大于0的值
    s.compare(s); //相等
    s.compare(0,2,s,2,2); //用”ab”和”cd”进行比较 小于零
    s.compare(1,2,”bcx”,2); //用”bc”和”bc”比较。
    怎么样?功能够全的吧!什么?还不能满足你的胃口?好吧,那等着,后面有更个性化的比较算法。先给个提示,使用的是STL的比较算法。什么?对STL一窍不通?靠,你重修吧!

    2.5 更改内容


    这在字符串的操作中占了很大一部分。
    首先讲赋值,第一个赋值方法当然是使用操作符=,新值可以是string(如:s=ns) 、c_string(如:s=”gaint”)甚至单一字符(如:s='j')。还可以使用成员函数assign(),这个成员函数可以使你更灵活的对字符串赋值。还是举例说明吧:
    s.assign(str); //不说
    s.assign(str,1,3);//如果str是”iamangel” 就是把”ama”赋给字符串
    s.assign(str,2,string::npos);//把字符串str从索引值2开始到结尾赋给s
    s.assign(“gaint”); //不说
    s.assign(“nico”,5);//把'n' ‘I' ‘c' ‘o' ‘/0'赋给字符串
    s.assign(5,'x');//把五个x赋给字符串
    把字符串清空的方法有三个:s=””;s.clear();s.erase();(我越来越觉得举例比说话让别人容易懂!)。
    string提供了很多函数用于插入(insert)、删除(erase)、替换(replace)、增加字符。
    先说增加字符(这里说的增加是在尾巴上),函数有 +=、append()、push_back()。

    举例如下:
    s+=str;//加个字符串
    s+=”my name is jiayp”;//加个C字符串
    s+='a';//加个字符
    s.append(str);
    s.append(str,1,3);//不解释了 同前面的函数参数assign的解释
    s.append(str,2,string::npos)//不解释了
    s.append(“my name is jiayp”);
    s.append(“nico”,5);
    s.append(5,'x');
    s.push_back(‘a');//这个函数只能增加单个字符对STL熟悉的理解起来很简单

    也许你需要在string中间的某个位置插入字符串,这时候你可以用insert()函数,这个函数需要你指定一个安插位置的索引,被插入的字符串将放在这个索引的后面。
          s.insert(0,”my name”);
          s.insert(1,str);
    这种形式的insert()函数不支持传入单个字符,这时的单个字符必须写成字符串形式(让人恶心)。既然你觉得恶心,那就不得不继续读下面一段话:为了插 入单个字符,insert()函数提供了两个对插入单个字符操作的重载函数:insert(size_type index,size_type num,chart c)和insert(iterator pos,size_type num,chart c)。其中size_type是无符号整数,iterator是char*,所以,你这么调用insert函数是不行的:insert(0,1, 'j');这时候第一个参数将转换成哪一个呢?所以你必须这么写:insert((string::size_type)0,1,'j')!第二种形式指 出了使用迭代器安插字符的形式,在后面会提及。顺便提一下,string有很多操作是使用STL的迭代器的,他也尽量做得和STL靠近。

    删除函数erase()的形式也有好几种(真烦!),替换函数replace()也有好几个。

    举例吧:
    string s=”il8n”;
    s.replace(1,2,”nternationalizatio”);//从索引1开始的2个替换成后面的C_string
    s.erase(13);//从索引13开始往后全删除
    s.erase(7,5);//从索引7开始往后删5个

    2.6提取子串和字符串连接


    题取子串的函数是:substr(),形式如下:
    s.substr();//返回s的全部内容
    s.substr(11);//从索引11往后的子串
    s.substr(5,6);//从索引5开始6个字符
    把两个字符串结合起来的函数是+。(谁不明白请致电120)

    2.7输入输出操作


    1.>> 从输入流读取一个string。
    2.<< 把一个string写入输出流。
    另一个函数就是getline(),他从输入流读取一行内容,直到遇到分行符或到了文件尾。

    2.8搜索与查找


    查找函数很多,功能也很强大,包括了:
    find()
    rfind()
    find_first_of()
    find_last_of()
    find_first_not_of()
    find_last_not_of()

    这些函数返回符合搜索条件的字符区间内的第一个字符的索引,没找到目标就返回npos。所有的函数的参数说明如下:
    第一个参数是被搜寻的对象。第二个参数(可有可无)指出string内的搜寻起点索引,第三个参数(可有可无)指出搜寻的字符个数。比较简单,不多说不理解的可以向我提出,我再仔细的解答。当然,更加强大的STL搜寻在后面会有提及。

    最后再说说npos的含义,string::npos的类型是string::size_type,所以,一旦需要把一个索引与npos相比,这个索引值必须是string::size)type类型的,更多的情况下,我们可以直接把函数和npos进行比较(如:if(s.find(“jia”)== string::npos))。

    string类的构造函数:
    string(const char *s);    //用c字符串s初始化
    string(int n,char c);     //用n个字符c初始化
    此外,string类还支持默认构造函数和复制构造函数,如string s1;string s2="hello";都是正确的写法。当构造的string太长而无法表达时会抛出length_error异常

    string类的字符操作:
    const char &operator[](int n)const;
    const char &at(int n)const;
    char &operator[](int n);
    char &at(int n);
    operator[]和at()均返回当前字符串中第n个字符的位置,但at函数提供范围检查,当越界时会抛出out_of_range异常,下标运算符[]不提供检查访问。
    const char *data()const;//返回一个非null终止的c字符数组
    const char *c_str()const;//返回一个以null终止的c字符串
    int copy(char *s, int n, int pos = 0) const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中,返回实际拷贝的数目

    string的特性描述:
    int capacity()const;    //返回当前容量(即string中不必增加内存即可存放的元素个数)
    int max_size()const;    //返回string对象中可存放的最大字符串的长度
    int size()const;        //返回当前字符串的大小
    int length()const;       //返回当前字符串的长度
    bool empty()const;        //当前字符串是否为空
    void resize(int len,char c);//把字符串当前大小置为len,并用字符c填充不足的部分

    string类的输入输出操作:
    string类重载运算符operator>>用于输入,同样重载运算符operator<<用于输出操作。
    函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中,以换行符'\n'分开。

    string的赋值:
    string &operator=(const string &s);//把字符串s赋给当前字符串
    string &assign(const char *s);//用c类型字符串s赋值
    string &assign(const char *s,int n);//用c字符串s开始的n个字符赋值
    string &assign(const string &s);//把字符串s赋给当前字符串
    string &assign(int n,char c);//用n个字符c赋值给当前字符串
    string &assign(const string &s,int start,int n);//把字符串s中从start开始的n个字符赋给当前字符串
    string &assign(const_iterator first,const_itertor last);//把first和last迭代器之间的部分赋给字符串

    string的连接:
    string &operator+=(const string &s);//把字符串s连接到当前字符串的结尾
    string &append(const char *s);            //把c类型字符串s连接到当前字符串结尾
    string &append(const char *s,int n);//把c类型字符串s的前n个字符连接到当前字符串结尾
    string &append(const string &s);    //同operator+=()
    string &append(const string &s,int pos,int n);//把字符串s中从pos开始的n个字符连接到当前字符串的结尾
    string &append(int n,char c);        //在当前字符串结尾添加n个字符c
    string &append(const_iterator first,const_iterator last);//把迭代器first和last之间的部分连接到当前字符串的结尾

    string的比较:
    bool operator==(const string &s1,const string &s2)const;//比较两个字符串是否相等
    运算符">","<",">=","<=","!="均被重载用于字符串的比较;
    int compare(const string &s) const;//比较当前字符串和s的大小
    int compare(int pos, int n,const string &s)const;//比较当前字符串从pos开始的n个字符组成的字符串与s的大小
    int compare(int pos, int n,const string &s,int pos2,int n2)const;//比较当前字符串从pos开始的n个字符组成的字符串与s中pos2开始的n2个字符组成的字符串的大小
    int compare(const char *s) const;
    int compare(int pos, int n,const char *s) const;
    int compare(int pos, int n,const char *s, int pos2) const;
    compare函数在>时返回1,<时返回-1,==时返回0   
    string的子串:
    string substr(int pos = 0,int n = npos) const;//返回pos开始的n个字符组成的字符串

    string的交换:
    void swap(string &s2);    //交换当前字符串与s2的值

    string类的查找函数:
    int find(char c, int pos = 0) const;//从pos开始查找字符c在当前字符串的位置
    int find(const char *s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
    int find(const char *s, int pos, int n) const;//从pos开始查找字符串s中前n个字符在当前串中的位置
    int find(const string &s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
    //查找成功时返回所在位置,失败返回string::npos的值
    int rfind(char c, int pos = npos) const;//从pos开始从后向前查找字符c在当前串中的位置
    int rfind(const char *s, int pos = npos) const;
    int rfind(const char *s, int pos, int n = npos) const;
    int rfind(const string &s,int pos = npos) const;
    //从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置,成功返回所在位置,失败时返回string::npos的值
    int find_first_of(char c, int pos = 0) const;//从pos开始查找字符c第一次出现的位置
    int find_first_of(const char *s, int pos = 0) const;
    int find_first_of(const char *s, int pos, int n) const;
    int find_first_of(const string &s,int pos = 0) const;
    //从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。查找失败返回string::npos
    int find_first_not_of(char c, int pos = 0) const;
    int find_first_not_of(const char *s, int pos = 0) const;
    int find_first_not_of(const char *s, int pos,int n) const;
    int find_first_not_of(const string &s,int pos = 0) const;
    //从当前串中查找第一个不在串s中的字符出现的位置,失败返回string::npos
    int find_last_of(char c, int pos = npos) const;
    int find_last_of(const char *s, int pos = npos) const;
    int find_last_of(const char *s, int pos, int n = npos) const;
    int find_last_of(const string &s,int pos = npos) const;
    int find_last_not_of(char c, int pos = npos) const;
    int find_last_not_of(const char *s, int pos = npos) const;
    int find_last_not_of(const char *s, int pos, int n) const;
    int find_last_not_of(const string &s,int pos = npos) const;
    //find_last_of和find_last_not_of与find_first_of和find_first_not_of相似,只不过是从后向前查找

    string类的替换函数:
    string &replace(int p0, int n0,const char *s);//删除从p0开始的n0个字符,然后在p0处插入串s
    string &replace(int p0, int n0,const char *s, int n);//删除p0开始的n0个字符,然后在p0处插入字符串s的前n个字符
    string &replace(int p0, int n0,const string &s);//删除从p0开始的n0个字符,然后在p0处插入串s
    string &replace(int p0, int n0,const string &s, int pos, int n);//删除p0开始的n0个字符,然后在p0处插入串s中从pos开始的n个字符
    string &replace(int p0, int n0,int n, char c);//删除p0开始的n0个字符,然后在p0处插入n个字符c
    string &replace(iterator first0, iterator last0,const char *s);//把[first0,last0)之间的部分替换为字符串s
    string &replace(iterator first0, iterator last0,const char *s, int n);//把[first0,last0)之间的部分替换为s的前n个字符
    string &replace(iterator first0, iterator last0,const string &s);//把[first0,last0)之间的部分替换为串s
    string &replace(iterator first0, iterator last0,int n, char c);//把[first0,last0)之间的部分替换为n个字符c
    string &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0,last0)之间的部分替换成[first,last)之间的字符串

    string类的插入函数:
    string &insert(int p0, const char *s);
    string &insert(int p0, const char *s, int n);
    string &insert(int p0,const string &s);
    string &insert(int p0,const string &s, int pos, int n);
    //前4个函数在p0位置插入字符串s中pos开始的前n个字符
    string &insert(int p0, int n, char c);//此函数在p0处插入n个字符c
    iterator insert(iterator it, char c);//在it处插入字符c,返回插入后迭代器的位置
    void insert(iterator it, const_iterator first, const_iterator last);//在it处插入[first,last)之间的字符
    void insert(iterator it, int n, char c);//在it处插入n个字符c

    string类的删除函数
    iterator erase(iterator first, iterator last);//删除[first,last)之间的所有字符,返回删除后迭代器的位置
    iterator erase(iterator it);//删除it指向的字符,返回删除后迭代器的位置
    string &erase(int pos = 0, int n = npos);//删除pos开始的n个字符,返回修改后的字符串

    string类的迭代器处理:
    string类提供了向前和向后遍历的迭代器iterator,迭代器提供了访问各个字符的语法,类似于指针操作,迭代器不检查范围。

    用string::iterator或string::const_iterator声明迭代器变量,const_iterator不允许改变迭代的内容。常用迭代器函数有:
    const_iterator begin()const;
    iterator begin();                //返回string的起始位置
    const_iterator end()const;
    iterator end();                    //返回string的最后一个字符后面的位置
    const_iterator rbegin()const;
    iterator rbegin();                //返回string的最后一个字符的位置
    const_iterator rend()const;
    iterator rend();                    //返回string第一个字符位置的前面
    rbegin和rend用于从后向前的迭代访问,通过设置迭代器string::reverse_iterator,string::const_reverse_iterator实现

    字符串流处理:
    通过定义ostringstream和istringstream变量实现,<sstream>头文件中
    例如:
    string input("hello,this is a test");
    istringstream is(input);
    string s1,s2,s3,s4;
    is>>s1>>s2>>s3>>s4;//s1="hello,this",s2="is",s3="a",s4="test"
    ostringstream os;
    os<<s1<<s2<<s3<<s4;
    cout<<os.str();

    一直弄不清楚c++string变量中存储数字的原理,现在也是很模糊,先把知道的写上

    1如果往string变量中输入一个数字输出也是一个数字

    2如果往string变量中输入一个数字,但需要进行计算的时候需要-'0'

    3通过两个数字相加得到的第三个数字存入string中的时候,需要+'0'
     

    转载自:c++ string头文件

    展开全文
  • header该 header 介绍字符串类型,字符特征和一组转换函数类模板(class template )basic_string通用字符串类模板char_traitschar型字符串模板类的实例(class )stringString类u16string16位 String 字符类u32string32...

    header

    该 header 介绍字符串类型,字符特征和一组转换函数

    类模板

    (class template )

    basic_string

    通用字符串类模板

    char_traits

    char型字符串模板

    类的实例

    (class )

    string

    String类

    u16string

    16位 String 字符类

    u32string

    32位 String 字符类

    wstring

    宽 string 类

    函数

    (function template )

    string 转换成其他

    stoi

    转换 string -> integer

    stol

    转换 string -> long int

    stoul

    转换 string -> unsigned integer

    stoll

    转换 string -> long long

    stoull

    转换 string -> unsigned long long

    stof

    转换 string -> float

    stod

    转换 string -> double

    stold

    转换 string -> long double

    其他转换成strings

    (function )

    to_string

    转换 numerical value -> string

    to_wstring

    转换 numerical value -> wide string

    访问元素

    (function template )

    begin

    将迭代器返回到开头(增长方向:begin -> end)

    end

    将迭代器返回到结尾

    std::string

    class

    迭代器操作:

    (public member function )

    begin

    将迭代器返回到开头(增长方向:begin -> end)

    end

    将迭代器返回到结尾

    rbegin

    返回反向迭代器以反向开始(增长方向:rbegin -> rend)

    rend

    将反向迭代器返回到反向结束

    cbegin(C++11)

    将const_iterator返回到开头(与begin类似,区别在于begin指向的值可以改变,cbegin指向的值不可改变)

    cend(C++11)

    将const_iterator返回到开头末尾

    crbegin(C++11)

    返回const_reverse_iterator以反向开始

    crend(C++11)

    将const_reverse_iterator返回到反向结束

    容量函数:

    (public member function )

    size

    返回字符串的长度

    length

    返回字符串的长度

    max_size

    返回可以拓展的最大容量

    resize

    改变目前字符串的长度

    capacity

    返回分配给字符串的大小

    reserve

    改变容器的预留空间的大小

    clear

    清空字符串的内容

    empty

    判断字符串是否为空

    shrink_to_fit(C++11)

    缩小字符串预留空间到较适合的程度

    元素访问:

    (public member function )

    operator[]

    获取字符串的字符

    at

    直接访问指定位置的元素,指定位置超出有效范围会报出异常

    back(C++11)

    返回字符串的尾部字符

    front(C++11)

    返回字符串的首部字符

    字符串操作:

    (public member function )

    operator+=

    附加其他字符串内容到该字符串

    append

    附加其他字符串内容到该字符串

    push_back

    将字符附加到字符串

    assign

    为字符串分配一个新值,替换其当前内容

    insert

    指定位置插入字符,或者插入字符串

    erase

    擦除指定长度的字符串

    replace

    在指定位置使用新的值代替原来的字符串的部分值

    swap

    交换两个字符串的内容

    pop_back(C++11)

    删除最后一个字符

    字符串操作:

    (public member function )

    c_str

    获取等效的 C 字符串

    data

    获取等效的 C 字符串

    get_allocator

    Get allocator (public member function )

    copy

    获取字符串到指定的 C 字符串

    find

    在字符串中查找指定内容

    rfind

    在字符串中查找最后出现的内容

    find_first_of

    在字符串中查找字符

    find_last_of

    从末尾反向查找字符串中的字符

    find_first_not_of

    在字符串中查找非指定的所有字符的字符

    find_last_not_of

    从末尾反向查找非指定的所有字符的字符

    substr

    生成包含原字符串的所有值或者部分值的副本

    compare

    比较两个字符串

    Member constants

    (public static member constant )

    npos

    Maximum value for size_t (public static member constant )

    非成员函数重载

    (function )

    operator+

    连接字符串

    relational operators

    字符串的关系运算符

    swap

    交换两个字符串的值

    operator>>

    从流中提取字符串

    operator<<

    将字符串插入到流

    getline

    获取从流到字符串的行

    展开全文
  • C++ String头文件详解

    千次阅读 2020-01-30 20:53:39
    对于一些喜欢用c++编程或者做题的人来说,字符串string是经常要用到的。所以我们要了解其中的一些函数以及使用方法 清单一,声明: (1)string s               &...

    对于一些喜欢用c++编程或者做题的人来说,字符串string是经常要用到的。所以我们要了解其中的一些函数以及使用方法

    清单一,声明:

    (1)string s                                 //生成一个空字符串s
    (2)string s(str)                          //拷贝构造函数 生成str的复制品
    (3)string s(str,stridx)               //将字符串str内“始于位置stridx”的部分当作字符串的初值
    (4)string s(str,stridx,strlen)    //将字符串str内“始于stridx且长度顶多strlen”的部分作为字符串的初值
    (5)string s(cstr)                        //将C字符串作为s的初值
    (6)string s(chars,chars_len)  //将C字符串前chars_len个字符作为字符串s的初值。
    (7)string s(num,c)                   //生成一个字符串,包含num个c字符
    (8)string s(beg,end)                //以区间beg;end(不包含end)内的字符作为字符串s的初值
    (9)s.~string()                            //销毁所有字符,释放内存




    清单二,函数:

    (1)swap()                                      //交换两个字符串的内容
    (2)==,!=,<,<=,>,>=,compare()      //比较字符串
    (3) +=,append(),push_back()      //在尾部添加字符
    (4)insert()                                     //插入字符
    (4) erase()                                    //删除字符
    (5)clear()                                      //删除全部字符
    (6)replace()                                  //替换字符
    (7)+                                               //串联字符串
    (8) ==,!=,<,<=,>,>=,compare()     //比较字符串
    (9)size(),length()                          //返回字符数量
    (10) max_size()                            //返回字符的可能最大个数
    (11)empty()                                  //判断字符串是否为空
    (12) capacity()                             //返回重新分配之前的字符容量
    (13) reserve()                               //保留一定量内存以容纳一定数量的字符
    (14) [ ], at()                                   //存取单一字符
    (15)>>,getline()                             //从stream读取某值
    (16)<<                                            //将谋值写入stream
    (17) copy()                                    //将某值赋值为一个C_string
    (18) c_str()                                   //将内容以C_string返回
    (19)data()                                      //将内容以字符数组形式返回
    (20)substr()                                  //返回某个子字符串
    (21)查找函数
    (22)begin() end()                         //提供类似STL的迭代器支持
    (23)rbegin() rend()                     //逆向迭代器
    (24)get_allocator()                     //返回配置器




    经常使用的函数详解:

    (1)c_str()
    功能:从一个string得到c类型的字符数组
    原型:const char * c_str();
    c_str()函数返回一个指向正规C字符串的指针常量, 内容与本string串相同
    这是为了与c语言兼容,在c语言中没有string类型,故必须通过string类对象的成员函数c_str()把string 对象转换成c中的字符串样式

    注意:一定要使用strcpy()函数 等来操作方法c_str()返回的指针
    比如:最好不要这样:

    char* c; 
    string s="1234"; 
    c = s.c_str(); //c最后指向的内容是垃圾,因为s对象被析构,其内容被处理,同时,编译器也将报错——将一个const char *赋与一个char *
    

    应该这样用:

    char c[20]; 
    string s="1234"; 
    strcpy(c,s.c_str()); 
    

    这样才不会出错,c_str()返回的是一个临时指针,不能对其进行操作
    c_str()返回的是一个分配给const char * 的地址,其内容已设定为不可变更,如果再把此地址赋给一个可以变更内容的char * 变量,就会产生冲突,在2010中是不被允许的。但是如果放入函数调用,或者直接输出,因为这些函数和输出都是把字符串指针作为 const char*引用的,所以不会有问题。
    再举个例子
    c_str() 以 char * 形式传回 string 内含字符串
    如果一个函数要求char * 参数,可以使用c_str()方法:

    string s = "Hello World!";
    printf("%s", s.c_str()); //输出 "Hello World!"
    





    (2)substr()函数
    substr(start, length)方法:返回一个从指定位置开始,并具有指定长度的子字符串。
    参数:
    1.start:必选。所需的子字符串的起始位置。字符串中第一个字符的索引为 0。
    2.length:可选项。返回的子字符串中包含的字符数。

    
    int main(){   
        string s = "12345";
    	string s1 = s.substr(3);
    	string s2 = s.substr(2, 3);
    	cout << s1 << ' ' << s2;
        return 0;
    }
    

    输出为:45 345

    展开全文
  • 关于string头文件

    千次阅读 2018-04-28 16:59:26
    C++中不包含string头文件包含string头文件的区别何在,为何都能使用string类来创建对象?答:今天特别无聊,这个问题我也一直奇怪,搜索也没满意的答案,就自己猜测了。代码实测使用string类创建实例只需要包含...
  • C语言中的string头文件解析

    万次阅读 多人点赞 2017-12-29 00:12:20
    标准库提供了一些函数用于处理字符串,它们的原型位于头文件string.h中。 •string.h头文件定义了一个变量: size_t:这是无符号整数类型,它是 sizeof 关键字的结果。 •定义了一个宏: NULL:这个宏是一个空...
  • 1.#include //不可以定义string s;可以用到strcpy等函数using namespace std;#include //可以定义string s;可以用到strcpy等函数using namesapce std;#include //不可以定义string s;可以用到strcpy等函数2.1)...
  • c++ string头文件

    万次阅读 多人点赞 2016-10-13 18:25:36
    标准c++中string类函数介绍 注意不是CString 之所以抛弃char*的字符串而选用C++标准程序库中的string类,是因为他和前者比较起来,不必 担心内存是否足够、字符串长度等等,而且作为一个类出现,他集成的操作...
  • string头文件函数用法大总结

    千次阅读 2018-08-18 03:18:26
    C++对应的头文件: #include &lt;cstring&gt; C对应的头文件: #include &lt;string.h&gt; 声明一个字符串变量 1)string s;//声明s字符串 2)string s(str);//str赋给s 3)string s(str...
  • 1)文件cstring,和string.h对应,c++版本的头文件包含比如strcpy之类的字符串处理函数2)文件string.h,和cstring对应,c版本的头文件包含比如strcpy之类的字符串处理函数3)文件string包含std::string的定义...
  • 因为我们通常使用的 < iostream > 头文件包含了 < string > 头文件
  • 不完全统计,C语言标准库中的头文件有15个之多,所以我主要介绍常用的这四个头文件stdio.h,string.h,math.h,stdlib.h,以后用到其他的再做补充。下面上干货:1.:定义了输入输出函数、类型以及宏,函数几乎占了标准...
  • String头文件与CString头文件

    千次阅读 2019-01-22 10:16:08
    String头文件与CString头文件
  • string类型需要头文件

    千次阅读 2020-03-15 10:57:41
    1、string类型的变量是什么? 2、常用的string类型的头文件有哪些? 3、为什么string类型不需要头文件? 4、实例图片
  • string头文件与cstring头文件

    千次阅读 2015-03-19 23:41:18
    首先说string头文件 1、 包装了std的C++头文件 2、 旧的C头文件 3、cstring.h> 旧C头文件的std版本,切记,这不是cstring的头文件 详见effective c++ 的第49条 再说cstring的头文件 注...
  • 3.31C++中string头文件

    2019-03-31 14:04:41
    ·说明C++中string头文件中部分函数应用 #include <string> using namespace std; 1.构造函数(Constructors) 语法: string(); string( size_type length, char ch ); string( const char *str )...
  • string.h函数与形参类型:函数功能:返回值:例子:1.memcmp函数与形参类型:int memcmp(buf1,buf2,count);void * buf1,void buf2,int count函数功能:按字典顺序比较由buf1和buf2指向数组的前count个字符。返回值:...
  • 头文件stringstring.h的区别

    千次阅读 2019-03-08 21:32:38
    头文件stringstring.h的区别 在C++中,#include&lt;iostream&gt;与#include&lt;iostream.h&gt;的区别: 前者要使用更新的编译器(其实大部分编译器都支持,除了某些搞嵌入式的编译器)。 iostream...
  • 头文件cstring、stringstring.h的区别

    千次阅读 2022-01-30 14:33:30
    是C++标准库头文件,使用stirng类型必须首先包含string头文件,用于字符串操作,string类型可以进行+、 =、 +=、 >等运算。std::string 类实际上是 STL 模板类 std::basic_string 的具体化。 #include<string&...
  • C语言 string.h头文件

    千次阅读 2020-03-13 02:08:10
    C标准要求在使用字符串函数时要包含头文件string.h,在使用字符函数时包含头文件 ctype.h 函数名 函数原型 功能 返回值 包含文件 isdigit int isdigit (int ch) 检验ch...
  • string函数头文件

    千次阅读 2021-05-23 01:47:01
    string.h头文件中有什么函数string.h头文件中的函数:#include //STL 通用算法#include //STL 位集容器#include //复数类#include //STL双端队列容器#include //异常处理类#include //STL 线性列表容器 7、#include ...
  • 要使用字符串处理函数,首先要包括它们所属的头文件。 #include<string.h> 整行输入输出函数 整行输入函数gets() 用法: gets (字符数组); gets函数表达时,将会从要求键盘输入一串字符,直至遇到换行符’...
  • 跟着视频一步步来的,可是我打出来就不行,快要砸电脑了,不是说C++包含头文件include就可以用string的嘛
  • jni.h头文件

    2021-04-22 09:03:54
    本文由我司收集整编,推荐下载,如有疑问,请与我司联系 无法使用 javah 无法使用 javah -stubs 生成... 我们要用的命令是 javah -d -classpath javah 是生成 jni 头文件的命令; -d 是生成的头文件存放的目录(这个目录....
  • 在C++中,#include<iostream>...喔,原来iostream是C++的头文件,iostream.h是C的头文件,即标准的C++头文件没有.h扩展名,将以前的C的头文件转化为C++的头文件后,有时加上c的前缀表示来自于c...
  • void 连接字符串不用string头文件(char* a, char* aa, char* aaa) { int z = 0, d = 0, dd = 0; while (a[d++] != '\0'); --d; while (aa[dd++] != '\0'); --dd; while (z < d)aaa[z] = a[z++]; z = 0; ...
  • 本文主要向大家介绍了C语言学习之strings.h 与 string.h 头文件的区别,通过具体的内容向大家展示,希望对大家学习C语言有所帮助。今天使用 man string 来查看 string 文件的使用的方法(毕竟里面的函数名字和传入...
  • C++头文件中cstring和string的区别

    千次阅读 2020-10-14 09:01:41
    是C++标准库头文件包含了拟容器class std::string的声明(不过class string事实上只是basic_string的typedef),用于字符串操作。 是C标准库头文件<string.h>的C++标准库版本,包含了C风格字符串(NUL即’\0...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 155,907
精华内容 62,362
关键字:

包含string的头文件