stricmp\strcmpi、strnicmp
功能:串比较,以大小写不敏感方式比较。
用法:int stricmp(char *str1, char *str2); 也可写成strcmpi() 其宏定义
int strnicmp(char *str1, char *str2, size_t n);
#include <iostream> #include <cstring> using namespace std; int main(void) { int ptr; const char *buf1="BBB", *buf2="bbb"; ptr=stricmp(buf2,buf1); if(ptr>0) cout<<"buf2 is greater than buf1"<<endl; else if(ptr<0) cout<<"buf2 is less than buf1"<<endl; else if(ptr==0) cout<<"buf2 equals buf1"<<endl; return 0; }
提示: 某些编译器已废止弃用这三个函数。
注:无对应函数,先把两个字串同转大写或小写再进行比较。
strchr、strrchr
功能:查找指定字符在串中首次出现的位置,返回一个指向str中指定字符首次出现的指针,如找不到则返回一个空指针。前者为从左到右正方向查找,后者为从右向左反方向查找。
用法:char *strchr(char *str, char c);
char *strrchr(char *str, char c);
#include <iostream> #include <cstring> using namespace std; int main(void) { char str[20]; char c='s'; strcpy(str,"It\'s a string"); //位置索引从0开始,3即是第4个字符 char *p=strchr(str,c); if(p) //p-str==3 指针减法运算 cout<<"The character "<<c<<" is at position:"<<p-str<<endl; else cout<<"The character was not found!"<<endl; cout<<p<<endl; //指针已移位,显示为:s a string char *q=strrchr(str,c); //反向查找,位置索引还是从0开始,7即是第8个字符 if(q) //q-str==7 指针减法运算 cout<<"The character "<<c<<" is at position:"<<q-str<<endl; else cout<<"The character was not found!"<<endl; cout<<q<<endl; //指针已移位,显示为:string return 0; }
提示: 打开网址 cpp.sh/4m2on,点RUN查看运行结果。
strstr
功能:查找子串,指定子串在字符串中首次出现的位置。返回一个指向str中首次出现substr的指针,如找不到则返回一个空指针。
用法:char *strstr(char *str, char *substr);
#include <iostream> #include <cstring> using namespace std; int main(void) { char str[20]; char s[4]="str"; strcpy(str,"It\'s a string"); //位置索引从0开始,7即是第8个字符开始 char *p=strstr(str,s); if(p) //p-str==7 指针减法运算 cout<<"The substring "<<s<<" is at position:"<<p-str<<endl; else cout<<"The substring was not found!"<<endl; cout<<p<<endl; //指针已移位,显示为:string return 0; }
提示: 打开网址 cpp.sh/4tkva ,点RUN查看运行结果。
string::find、string::rfind 查找字符或子串
#include <iostream> #include <string> using namespace std; int main(void) { string str="It\'s a string."; char c='s'; string::size_type pos; //或声明为 size_t pos; 如串长不是巨大的话可用int代替 //C++函数重载,查找字符或子串用同一函数名 pos=str.find(c); //显示:3 正向查找,类似于strchr(str,c) cout<<pos<<endl; pos=str.rfind(c); //显示:7 反向查找,类似于strrchr(str,c) cout<<pos<<endl; string substr="string"; pos=str.find(substr); //显示:7 cout<<pos<<endl; pos=str.rfind(substr); //显示:7 cout<<pos<<endl; //另可以指定查找位置,返回的还在全串的位置 pos=str.find(substr,5); //显示:7 cout<<pos<<endl; pos=str.find(substr,8); //没找到则返回一个很大的数=Maximum value for size_t //(实际上就是成员常量string::npos) 声明int型则返回-1 cout<<pos<<endl; // string::npos 的用法: if (pos != string::npos) //string::npos 可以用 str.npos 替代 cout << "position is:" << pos << endl; else cout << "Not found the substring:" + substr; //此处没找到的原因,设置了开始位置 8 return 0; }
提示: 打开网址 cpp.sh/6skc7,点RUN查看运行结果。
strspn、strcspn
功能:查找前缀,计算字符串str中从头开始连续有几个字符都 [属于/不属于] 字符串control。前者返回第一次失配前匹配的字符数,后者返回第一次匹配前失配的字符数。
用法:size_t strspn (const char *str, const char *control);
size_t strcspn (const char *str, const char *control);
#include <iostream> #include <cstring> using namespace std; int main(void) { const char *str="(3+3/7)*7 or (4-4/7)*7 = 24"; cout<<strspn(str,"()")<<endl; //返回1,str前部连续的有1个字符匹配,即数字3之前的字符数 cout<<strspn(str,"37()+-*/")<<endl; //返回9,str前部连续有9个字符匹配,即空格前的字符数 cout<<strspn(str,"1234567890")<<endl<<endl; //返回0,字符串str非数字起始 cout<<strcspn(str," ")<<endl; //返回9,str前部9个字符未出现空格 cout<<strcspn(str,"+-*/")<<endl; //返回2,str前部2个字符未出现+-*/ cout<<strcspn(str,"1234567890")<<endl; //返回1,即第1个字符不是数字 return 0; }
提示: 打开网址 cpp.sh/34vlm,点RUN查看运行结果。
string::find_first_of、string::find_first_not_of
#include <iostream> #include <string> using namespace std; int main(void) { size_t index,last=0; string s="(3+3/7)*7 or (4-4/7)*7 = 24"; string separator="37()+-*/"; index=s.find_first_of(separator,last); while (index==last++) index=s.find_first_of(separator,last); cout<<"第一次失配前已匹配的字符数:"<<last-1<<endl; //显示9,即最后一个匹配的位置索引+1 last=0; separator="or"; do index=s.find_first_not_of(separator,last++); //注意:do-while和while-do的区别 while (index==last-1); cout<<"第一次匹配前已失配的字符数:"<<last-1<<endl; //显示10,即最后一个失配的位置索引+1 return 0; }
提示: 打开网址 cpp.sh/4fi7x,点RUN查看运行结果。
strpbrk
功能:查找字符集,查找breakset里任一字符第一次出现在dest里的位置,返回dest中第一次出现breakset中字符的指针,如果不存在返回NULL。
用法:char *strpbrk(const char *dest, const char *breakset);
#include <iostream> #include <cstring> using namespace std; int main(void) { const char *str="24 = (3+3/7)*7 or (4-4/7)*7"; const char *breakset="()^%"; //分界符中至少有一个字符属于str,否则返回NULL str=strpbrk(str,breakset); //左(最先出现,此时str=="(3+3/7)*7 or (4-4/7)*7" if (str) cout<<str<<endl; //cout输出NULL,程序会异常退出 //用do-while计算除分界符之外的字符数 unsigned int cnt=0; const char *separator="()+-*/ or"; do { str=strpbrk(str,separator); if (str==NULL) break; //找不到了就中断循环,否则以下操作会退出 cout<<cnt<<":"<<str<<endl; //本行测试用,可去掉 str+=strspn(str,separator); ++cnt; } while(str && *str); //cout<<str; //此时str==NULL,此处显示str就会中止退出 cout<<"\nThere are "<<cnt<<" digits."<<endl; return 0; }
提示: 打开网址 cpp.sh/9tgqj,点RUN查看运行结果。
string::find + string::substr
无对应函数,以上两个函数组合可以模拟strpbrk例程的效果。
#include <iostream> #include <string> using namespace std; int main(void) { string str="(3+3/7)*7 or (4-4/7)*7"; string sep="()+-*/ or"; int index=0,cnt=0; for(auto s:str){ if (sep.find(s)==string::npos) cout<<cnt++<<":"<<str.substr(index-1,str.size())<<endl; index++; } //cout<<str; //此时str还是原值,string类的优点之一 cout<<"\nThere are "<<cnt<<" digits."<<endl; return 0; }
提示: 打开网址 cpp.sh/2iuoy,点RUN查看运行结果。
strtok、(strtok_r、strtok_s)
功能:串分割,把字符串中用分界符分割成多个子串。saveptr记录的是每次被分割后剩余的部分。
用法:char *strtok(char *s, const char *delim);
char *strtok_r(char *str, const char *delim, char **saveptr); //linux版本
char *strtok_s(char *strToken, const char *strDelimit, char **buf); //windows版本
#include <iostream> #include <cstring> #include <vector> using namespace std; int main(void) { const char *tmp = "hello,Dev-C++"; char str[20]; strcpy(str,tmp); cout<<"str初值:"<<str<<endl; char *token = strtok(str,","); cout<<token<<endl; token=strtok(NULL,","); //str必须包含分界符,否则此行出错 cout<<token<< endl; cout<<"str终值:"<<str<<endl; //str被改变了! //strtok(str,delim)允许同时有多个分界符,但delim中至少有一个字符是str的子串 cout<<"\n多个子串可用while循环来分隔"<<endl; strcpy(str,tmp); //重新取值 token=strtok(str,",-"); while(token!=NULL){ cout<<token<<endl; token=strtok(NULL,",-"); } cout<<"\n把分割出来的子串装入容器中"<<endl; strcpy(str,tmp); //重新取值 vector<string>vect; token=strtok(str,",-"); while(token!=NULL){ vect.push_back(token); token=strtok(NULL,",-"); } for (auto v:vect) cout<<v<<endl; return 0; }
提示: 打开网址 cpp.sh/5fa2d,点RUN查看运行结果。
string::find_first_of + string::substr 串分割
#include <iostream> #include <string> #include <vector> using namespace std; int main(void) { vector<string>vect; size_t index,last=0; string s="Hello,Dev-C++"; string delim=",-"; index=s.find_first_of(delim,last); while (index!=s.npos){ vect.push_back(s.substr(last,index-last)); last=index+1; index=s.find_first_of(delim,last); } if (s.length()-last>0) vect.push_back(s.substr(last)); for(auto v:vect) cout<<v<<endl; return 0; }
提示: 打开网址 cpp.sh/92cka,点RUN查看运行结果。
strrev
功能:串倒序,所有字符反转顺序。
用法:char *strrev(char *str);
#include <iostream> #include <cstring> using namespace std; int main(void) { char str[15]; strcpy(str,"Hello,world!"); cout<<str<<endl; char *p=strrev(str); cout<<p<<endl; //显示: !dlrow,olleH return 0; }
提示: 某些编译器已废止弃用这个函数。
std::reverse(string::begin, string::end) 串倒序
或 string::assign(string::rbegin, string::rend)
用reverse算法全串倒序,需要#include<algorithm>;或用assign()函数反向赋值。
#include <iostream> #include <string> #include <cstring> #include <algorithm> using namespace std; int main(void) { string str="Hello,world!"; reverse(str.begin(),str.end()); //必须包括<algorithm>头文件 cout<<str<<endl; //显示: !dlrow,olleH //或用string::assign + string::rbegin rend str.assign(str.rbegin(),str.rend()); cout<<str<<endl; //显示: Hello,world! //reverse()算法也适用于C字符串、字符数组 char *c=(char*)str.c_str(); reverse(c,c+strlen(c)); cout<<c<<endl; //显示: !dlrow,olleH char s[20]; strcpy(s,c); reverse(s,s+strlen(s)); cout<<s<<endl; //显示: Hello,world! return 0; }
提示: 打开网址 cpp.sh/6vzuk ,点RUN查看运行结果。
swab
功能:交换字节,奇偶数位置的字符相互交换位置,nbytes通常要求是偶数。
用法:void swab (char *from, char *to, int nbytes);
#include <iostream> #include <cstring> using namespace std; int main(void) { char source[11]="1234567890"; char target[11]; swab(source,target,strlen(source)); cout<<source<<" | "<<target<<endl; //显示:1234567890 | 2143658709 return 0; }
string::swap
无对应函数,有个string::swap(string str1,string str2)函数,但它的功能是交换两个字符串的值。
#include <iostream> #include <string> using namespace std; int main(void) { string source="1234567890"; string target; target.swap(source); cout<<source<<" | "<<target<<endl; return 0; }
string Swab(string str);
自定义函数模拟实现swab()
#include<iostream> #include<string> using namespace std; string Swab(string); int main(void) { string str="1234567890"; cout<<str<<" | "<<Swab(str)<<endl; return 0; } string Swab(string str) { int i,j=0; for (auto&s:str){ if (j%2==1){ i=str.at(j-1); str.at(j-1)=s; s=i; } j++; } return str; }
提示: 打开网址 cpp.sh/8giax,点RUN查看运行结果。
strtol、strtod、strtoul
功能:字符串转整数或浮点数,转换前会跳过空格字符,如有不合条件的字符由endptr传回。非<cstring>库函数,包含在头文件 <cstdlib> 或 <stdlib.h>
用法:long strtol(char *str, char **endptr, int base); //base为整数的进制基数,十进制base==10
double strtod(char *str, char **endptr); //转浮点数,可以转换的字符有+-Ee.及数字
unsigned long strtoul(const char *nptr,char **endptr,int base); //转无符号长整型
#include <iostream> #include <cstdlib> using namespace std; int main() { char *endptr; char a[] = "123.4567890"; char b[] = "123.456Hann"; char c[] = "-123.456E-7"; cout<<strtol(a,NULL,10)<<endl; cout<<a<<endl<<endl; cout<<strtol(a,&endptr,10)<<endl; cout<<a<<endl; //a未被改变 cout<<endptr<<endl<<endl; cout<<strtod(b,&endptr)<<endl; cout<<b<<endl; //b未被改变 cout<<endptr<<endl<<endl; cout<<strtod(c,NULL)<<endl; }
提示: 打开网址 cpp.sh/94bjb,点RUN查看运行结果。
用stringstream类转数字
#include <iostream> #include <sstream> #include <string> using namespace std; template<typename _Type> _Type str2number(string s) { _Type num; stringstream ss; ss<<s; ss>>num; ss.clear(); return num; } int main(void) { string str="1234.56789e-5"; long double a; long int b; double c; int d; a=str2number<long double>(str); b=str2number<long int>(str); c=str2number<double>(str); d=str2number<int>(str); cout<<a<<endl; cout<<b<<endl; cout<<c<<endl; cout<<d<<endl; return 0; }
提示: 打开网址 cpp.sh/6s6as,点RUN查看运行结果。
以上代码均在Dev-C++ 5.11上通过无错编译,其他字符串相关文章请阅《C++ <cstring>字符串库函数的自定义实现》
附录:
【转载】C++内存分配方式详解——堆、栈、自由存储区、全局/静态存储区和常量存储区
栈,就是那些由编译器在需要的时候分配,在不需要的时候自动清除的变量的存储区。里面的变量通常是局部变量、函数参数等。在一个进程中,位于用户虚拟地址空间顶部的是用户栈,编译器用它来实现函数的调用。和堆一样,用户栈在程序执行期间可以动态地扩展和收缩。
堆,就是那些由 new 分配的内存块,他们的释放编译器不去管,由我们的应用程序去控制,一般一个 new 就要对应一个 delete。如果程序员没有释放掉,那么在程序结束后,操作系统会自动回收。堆可以动态地扩展和收缩。
自由存储区,就是那些由 malloc 等分配的内存块,他和堆是十分相似的,不过它是用 free 来结束自己的生命的。
全局/静态存储区,全局变量和静态变量被分配到同一块内存中,在以前的 C 语言中,全局变量又分为初始化的和未初始化的(初始化的全局变量和静态变量在一块区域,未初始化的全局变量与静态变量在相邻的另一块区域,同时未被初始化的对象存储区可以通过 void* 来访问和操纵,程序结束后由系统自行释放),在 C++ 里面没有这个区分了,他们共同占用同一块内存区。
常量存储区,这是一块比较特殊的存储区,他们里面存放的是常量,不允许修改(当然,你要通过非正当手段也可以修改,而且方法很多)
明确区分堆与栈
在 BBS 上,堆与栈的区分问题,似乎是一个永恒的话题,由此可见,初学者对此往往是混淆不清的,所以我决定拿他第一个开刀。
首先,我们举一个例子: void f() { int* p=newint[5]; }
这条短短的一句话就包含了堆与栈,看到 new,我们首先就应该想到,我们分配了一块堆内存,那么指针 p 呢?他分配的是一块栈内存,所以这句话的意思就是:在栈内存中存放了一个指向一块堆内存的指针 p。在程序会先确定在堆中分配内存的大小,然后调用 operator new 分配内存,然后返回这块内存的首地址,放入栈中,他在 VC6 下的汇编代码如下:
00401028push 14h 0040102Acall operator new (00401060) 0040102Fadd esp,4 00401032mov dword ptr [ebp-8],eax 00401035mov eax,dword ptr [ebp-8] 00401038mov dword ptr [ebp-4],eax
这里,我们为了简单并没有释放内存,那么该怎么去释放呢?是 delete p 么?噢,错了,应该是 delete []p,这是为了告诉编译器:我删除的是一个数组,VC6 就会根据相应的 Cookie 信息去进行释放内存的工作。
好了,我们回到我们的主题:堆和栈究竟有什么区别?
主要的区别由以下几点:
1、管理方式不同;
2、空间大小不同;
3、能否产生碎片不同;
4、生长方向不同;
5、分配方式不同;
6、分配效率不同;
管理方式:对于栈来讲,是由编译器自动管理,无需我们手工控制;对于堆来说,释放工作由程序员控制,容易产生memory leak。
空间大小:一般来讲在 32 位系统下,堆内存可以达到4G的空间,从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲,一般都是有一定的空间大小的,例如,在VC6下面,默认的栈空间大小是1M(好像是,记不清楚了)。当然,我们可以修改:打开工程,依次操作菜单如下:Project->Setting->Link,在 Category 中选中 Output,然后在 Reserve 中设定堆栈的最大值和 commit。注意:reserve 最小值为 4Byte;commit 是保留在虚拟内存的页文件里面,它设置的较大会使栈开辟较大的值,可能增加内存的开销和启动时间。
碎片问题:对于堆来讲,频繁的 new/delete 势必会造成内存空间的不连续,从而造成大量的碎片,使程序效率降低。对于栈来讲,则不会存在这个问题,因为栈是先进后出的队列,他们是如此的一一对应,以至于永远都不可能有一个内存块从栈中间弹出,在他弹出之前,在他上面的后进的栈内容已经被弹出,详细的可以参考数据结构,这里我们就不再一一讨论了。
生长方向:对于堆来讲,生长方向是向上的,也就是向着内存地址增加的方向;对于栈来讲,它的生长方向是向下的,是向着内存地址减小的方向增长。
分配方式:堆都是动态分配的,没有静态分配的堆。栈有2种分配方式:静态分配和动态分配。静态分配是编译器完成的,比如局部变量的分配。动态分配由 malloc 函数进行分配,但是栈的动态分配和堆是不同的,他的动态分配是由编译器进行释放,无需我们手工实现。
分配效率:栈是机器系统提供的数据结构,计算机会在底层对栈提供支持:分配专门的寄存器存放栈的地址,压栈出栈都有专门的指令执行,这就决定了栈的效率比较高。堆则是 C/C++ 函数库提供的,它的机制是很复杂的,例如为了分配一块内存,库函数会按照一定的算法(具体的算法可以参考数据结构/操作系统)在堆内存中搜索可用的足够大小的空间,如果没有足够大小的空间(可能是由于内存碎片太多),就有可能调用系统功能去增加程序数据段的内存空间,这样就有机会分到足够大小的内存,然后进行返回。显然,堆的效率比栈要低得多。
从这里我们可以看到,堆和栈相比,由于大量 new/delete 的使用,容易造成大量的内存碎片;由于没有专门的系统支持,效率很低;由于可能引发用户态和核心态的切换,内存的申请,代价变得更加昂贵。所以栈在程序中是应用最广泛的,就算是函数的调用也利用栈去完成,函数调用过程中的参数,返回地址,EBP 和局部变量都采用栈的方式存放。所以,我们推荐大家尽量用栈,而不是用堆。
虽然栈有如此众多的好处,但是由于和堆相比不是那么灵活,有时候分配大量的内存空间,还是用堆好一些。
无论是堆还是栈,都要防止越界现象的发生(除非你是故意使其越界),因为越界的结果要么是程序崩溃,要么是摧毁程序的堆、栈结构,产生以想不到的结果,就算是在你的程序运行过程中,没有发生上面的问题,你还是要小心,说不定什么时候就崩掉,那时候 debug 可是相当困难的 :)
对了,还有一件事,如果有人把堆栈合起来说,那它的意思是栈,可不是堆,呵呵,清楚了?
static 用来控制变量的存储方式和可见性
函数内部定义的变量,在程序执行到它的定义处时,编译器为它在栈上分配空间,函数在栈上分配的空间在此函数执行结束时会释放掉,这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时,如何实现? 最容易想到的方法是定义一个全局的变量,但定义为一个全局变量有许多缺点,最明显的缺点是破坏了此变量的访问范围(使得在此函数中定义的变量,不仅仅受此 函数控制)。需要一个数据对象为整个类而非某个对象服务,同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部,对外不可见。
static 的内部机制:
静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用,所以静态数据成员不能在任何函数内分配空间和初始化。这样,它的空间分配有三个可能的地方,一是作为类的外部接口的头文件,那里有类声明;二是类定义的内部实现,那里有类的成员函数定义;三是应用程序的 main()函数前的全局数据声明和定义处。
静态数据成员要实际地分配空间,故不能在类的声明中定义(只能声明数据成员)。类声明只声明一个类的“尺寸和规格”,并不进行实际的内存分配,所以在类声明中写成定义是错误的。它也不能在头文件中类声明的外部定义,因为那会造成在多个使用该类的源文件中,对其重复定义。
static 被引入以告知编译器,将变量存储在程序的静态存储区而非栈上空间,静态数据成员按定义出现的先后顺序依次初始化,注意静态成员嵌套时,要保证所嵌套的成员已经初始化了。消除时的顺序是初始化的反顺序。
static 的优势:
可以节省内存,因为它是所有对象所公有的,因此,对多个对象来说,静态数据成员只存储一处,供所有对象共用。静态数据成员的值对每个对象都是一样,但它的 值是可以更新的。只要对静态数据成员的值更新一次,保证所有对象存取更新后的相同的值,这样可以提高时间效率。引用静态数据成员时,采用如下格式:
<类名>::<静态成员名>
如果静态数据成员的访问权限允许的话(即 public 的成员),可在程序中,按上述格式来引用静态数据成员。
Ps:
(1) 类的静态成员函数是属于整个类而非类的对象,所以它没有this指针,这就导致了它仅能访问类的静态数据和静态成员函数。
(2) 不能将静态成员函数定义为虚函数。
(3) 由于静态成员声明于类中,操作于其外,所以对其取地址操作,就多少有些特殊,变量地址是指向其数据类型的指针,函数地址类型是一个“nonmember 函数指针”。
(4) 由于静态成员函数没有 this 指针,所以就差不多等同于 nonmember 函数,结果就产生了一个意想不到的好处:成为一个 callback 函数,使得我们得以将 c++ 和 c-based x window 系统结合,同时也成功的应用于线程函数身上。
(5) static 并没有增加程序的时空开销,相反她还缩短了子类对父类静态成员的访问时间,节省了子类的内存空间。
(6) 静态数据成员在<定义或说明>时前面加关键字 static。
(7) 静态数据成员是静态存储的,所以必须对它进行初始化。
(8) 静态成员初始化与一般数据成员初始化不同:
初始化在类体外进行,而前面不加 static,以免与一般静态变量或对象相混淆;
初始化时不加该成员的访问权限控制符 private、public;
初始化时使用作用域运算符来标明它所属类;
所以我们得出静态数据成员初始化的格式: <数据类型><类名>::<静态数据成员名>=<值>
(9) 为了防止父类的影响,可以在子类定义一个与父类相同的静态变量,以屏蔽父类的影响。这里有一点需要注意:我们说静态成员为父类和子类共享,但我们有重复定义了静态成员,这会不会引起错误呢?不会,我们的编译器采用了一种绝妙的手法:name-mangling 用以生成唯一的标志。
附录内容转自http://www.cnblogs.com/daocaoren/archive/2011/06/29/2092957.html