C++字符串操作问题

Ｃ＋＋Ｓｔｒｉｎｇ操作

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变量实现，头文件中

例如：

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<

cout<

字符串处理函数（C++）

默认分类2010-03-24 22:40:13 阅读73 评论0 字号：大中小

1、比较字符串大小函数

1）忽略大小写---strcasecmp

函数原型：int strcasecmp (const char *s1, const char *s2);

函数说明：用来比较参数s1和s2字符串，比较时会自动忽略大小写的差异

2）忽略大小写—stricmp

函数原型：int stricmp(char *str1, char *str2);

函数说明：以大小写不敏感方式比较两个串

3）不忽略大小写—strcmp

函数原型：int strcmp(char*str1,char*str2);

函数说明：通过比较字串中各个字符的ASCII码，来比较参数Str1和Str2字符串，比较时考虑字符的大小写。

4）比较一部分—strncmpi

函数原型：int strncmpi(char *str1, char *str2, unsigned maxlen);

函数说明：比较字符串str1和str2的前maxlen个字符

5）内存区域比较---memcmp

函数原型：int memcmp(void*buf1,void *buf2,unsigned int count)

函数说明：比较内存区域buf1和buf2的前count个字节。Void*是指任何类型的指针。

6）内存区域部分比较-- memicmp Void*是指任何类型的指针。

函数原型：int memicmp(void*buf1,void *buf2,unsigned int count)

函数说明：比较内存区域buf1和buf2的前count个字节，但不区分大小写。

以上比较函数的返回值：若参数1中字符串和参数中2字符串相同则返回0；

若参数1中字符串长度大于参数2中字符串长度则返回大于0 的值；

若参数1中字符串长度小于参数2中字符串长度则返回小于0的值。

2、从字符串中提取子串

1）提取子串--strstr

函数原型：char* strstr(char*src,char*find)

函数说明：从字符串src中寻找find第一次出现的位置（不比较结束符NULL）

返回值：返回指向第一次出现find位置的指针，如果没有找到则返回NULL

2）提取分隔符间字串—strtok

函数原型：char *strtok(char*src，char*delim);

函数说明：分解字符串诶一组标记串，src为要分解的字符串，delim为分隔符字符串。

首次调用时，src必须指向要分解的字符串，随后调用要把s设成NULL；

strtok中src中查找包含在delim中的字符，并用NULL（’\0’）来替换直到找遍整个字符串。

返回值：从s开头开始的一个个被分割的串。当没有被分割的串时则返回NULL。

所有delim中包含的字符都会被滤掉，并将被滤掉的地方设为一处分割的节点。

举例：

#include

#include

int main(){

char *s="Golden Global View";

char *d=" ";

char *p;

p=strtok(s,d);

while(p){

printf("%s\n",p);

strtok(NULL,d);

}

return 0;

}

Global

View

3、字符串复制

1)字串复制--strcpy

函数原型：char*strcpy(char*dest,char*src)

函数说明：把src所指由NULL结束的字符串复制到dest所指的数组中。

其中，src和dest所致内存区域不可重叠且dest必须有足够的空间来容纳src的字符串。

返回值：返回指向dest的指针。

2）字串复制--strdup

函数原型：char* strdup(char*src)

函数说明：复制字符串src

返回值：返回指向被复制字符串的指针，所需空间有malloc（）分配且可以有free（）释放。

3）内存空间复制--memcpy

函数原型：void *memcpy(void *dest,void *src,unsigned int count);

函数说明：src和dest 所指内存区域不能重叠；由src所致内存区域复制count个字节到dest所指内存区域中。

返回值：返回指向dest的指针。

4、字符串连接

1）接尾连接--strcat

函数原型：char* strcat(char*dest,char*src)

函数说明：把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')并添加'\0'

2)部分连接--strncat

函数原型:char* strncat(char*dest,char*src,int n);

函数说明：把src所指字符串的前n个字符添加到dest结尾处（覆盖dest结尾处的’\0’）并添加’’\0’.

返回值：返回指向dest的指针。

5、从字符串中查找字符

1）内存区域找字符--memchr

函数原型：void *memchr(void*buf,char ch,usigned count)

函数说明：从buf所指内存区域的前count个字节查找字符ch，当第一次遇到字符ch时停止查找。

返回值：如果找到了，返回指向字符ch的指针；否则返回NULL

2）字串中找字符--strchr

函数原型:char* strchr(char*src,char ch)

函数说明：查找字符串s中首次出现字符ch的位置

返回值：返回首次出现c的位置的指针，如果s中不存在c则返回NULL

3）搜所现字符--strcspn

函数原型：int strcspn（char*src,char*find）

函数说明：在字符串src中搜寻find中所出现的字符

返回值：返回第一个出现的字符在src中的下标值，即src中出现而不在find中出现的字串的长度。

举例：

#include

#include

int main(){

char *s="Golden Global View";

int n;

n=strcspn(s,r);

printf("The first char both in s1 and s2 is: %c",s[n]);

return 0;

}

输出：The first char both in s1 and s2 is :e

4)匹配任一字符--strpbrk

函数原型：char*strpbrk(char*s1,char*s2)

函数说明：在字符串S1中寻找字符串S2中任何一个字符相匹配的第一个字符的位置，空字符不包括在内。返回值：返回指向S1中第一个相匹配的字符的指针，如果没有匹配字符则返回空指针。

举例：

#include

#include

int main(){

char *s1="Welcome To Beijing";

char *s2="BIT";

char *p;

p=strpbrk(s1,s2);

if(p)

printf("%s\n",p);

else printf("Not Found!\n");

return 0;

}

输出：To Beijing

6、其他函数

1）全部转成大写---strupr

函数原型：char*strupr(char*src)

函数说明：将字符串src转换成大写形式，只转换src中出现的小写字母，不改变其他字符

返回值：返回指向src的指针。

2）全部转成小写---strlwr

函数原型：char*strlwr(char*src)

函数说明：将字符串src转换成小写形式，只转换src中出现的大写字母，不改变其他字符

返回值：返回指向src的指针。

3）将字串逆向--strrev

函数原型：char*strrev（char*src）

函数说明：把字符串src的所有字符的顺序颠倒过来（不包括NULL）

返回值：返回指向颠倒顺序后的字符串指针

C字符串处理函数全

strcpy(char destination[], const char source[]); strcpy：将字符串source拷贝到字符串destination中。 strcpy函数应用举例 原型：strcpy(char destination[], const char source[]); 功能：将字符串source拷贝到字符串destination中 例程： #include #include void main(void) { char str1[10] = { "TsinghuaOK"}; char str2[10] = { "Computer"}; cout < #include void main(void) { char str1[10] = { "Tsinghua "}; char str2[10] = { "Computer"}; cout <

C语言课程设计报告---字符串处理

课程设计报告 课程设计题目：研究生初试录取 学生：俊 专业：计算机应用技术 班级： 1140302 指导教师：宋文琳 2012年 06 月 23日

目录 一）实验题目 (3) 二）实验目的 (3) 三）实验要求 (3) 四）实验思路 (4) 五）实验过程 (6) 六）实验调试和结果 (9) 七）实验小结 (13)

实验题目 字符串处理 （1）不使用系统库函数，编写多个函数实现； （2）定义字符数组存放字符串，从键盘输入； （3）调用不同的函数，实现字符串的连接、拷贝、比较、求字符串长度、对字符串字符进行排序、查找字符串中某个字符是否存在； （4）分别输出以上字符串处理的结果。 二）实验目的 本次课程设计的主要目的是综合运用所学的C语言知识解决一个比较实际的简单问题，侧重对数组、函数、指针、结构体等相关容的综合应用，使学生能进一步熟悉掌握C语言的基本语法，进一步提升编程能力并逐步培养编程思维，进而不断提高学生解决问题的能力，并为以后的语言学习打下良好的基础。三）实验要求 1. 学生独立完成课程设计的主要容； 2. 按照实验课表安排进行，不得无故旷课； 3．按照选题规则确定课程设计题目，不可随意更换，但可在完成规定的任务之后，根据 个人兴趣选做其它题目； 4．严格按照报告格式撰写课程设计报告； 5．程序实现方式可以自选，可采用指针、数组或其任意组合方式完成。

四）实验思路1）整体思路

五）实验过程 代码： #include void main() {void lianjie(char a[],char b[]); void kaobei(char a[],char b[]); void bijiao(char a[],char b[]); void qiuchangdu(char a[],char b[]); void paixu(char a[],char b[]); void chazhao(char a[],char b[],char c); char str1[50],str2[40]; char t; int i; printf("需要进行的操作：1.连接；2.拷贝；3.比较；4.求长度；5.排序；6.查找\n"); scanf("%d",&i); if(i==1) {printf("要连接的字符串1："); scanf("%s",str1); printf("要连接的字符串2："); scanf("%s",str2); lianjie(str1,str2);} else if(i==2) {printf("拷贝的字符串1："); scanf("%s",str1); printf("要拷贝的字符串2："); scanf("%s",str2); kaobei(str1,str2);} else if(i==3)

C语言中处理字符串的各种自定义函数(精)

C 语言中处理字符串的各种自定义函数 关于 strcpy,strcmp,strcat,strlen 的自定义函数,它是为了避免调用库函数对代码兼容的局限性。要注意如下一些问题: 1. 检查输入的两个指针是否有效; 2. 检查两个字符串是否以 NULL 结尾; 3. 检查目标指针的空间是否大于等于原字符串的空间。 一. strcpy 自定义 char * sef_strcpy(char *str1,char *str2 { If( (NULL==str1||(NULL==str2 { printf(“ invalid argument(s” ; return; } char *strcopy=str1; while(… \0? != *str1++=*str2++ ; *str1=? \0? ; return strcopy;

} 二. strcmp 的自定义 int sef_strcpy(char *str1,char *str2 { If( (NULL==str1||(NULL==str2 { printf(“ 输入参数错误,值为 NULL ! \n” ; return -1; } while(*str1&&*str2&&( *str1++==*str2++ ; return str1-str2; } 三. strcat 的自定义 char * sef_strcat(char *str1,char *str2 { If( (NULL==str1||(NULL==str2 { printf(“ 输入参数错误! ” ;

return; } char *strcopy=str1; while(… \0? !=*str1 {str++;} while(… \0? != (*str1++=*str2++ ; *str1=? \0? ; return strcopy; } 四. strlen 的自定义函数 int sef_strlen(char *str { if(NULL==str { printf(“ 输入参数错误,值为NULL ! ” ; char *p=str; while(… \0? !=*str++ ; return str-p-1;

C所有处理字符串函数和用法

C#字符串函数大全 C#字符串函数大全将包括Len Len(string|varname) 、Trim Trim(string) 、Ltrim Ltrim(string)等多项内容 LenLen(string|varname)返回字符串内字符的数目，或是存储一变量所需的字节数。 TrimTrim(string)将字符串前后的空格去掉 LtrimLtrim(string)将字符串前面的空格去掉 RtrimRtrim(string)将字符串后面的空格去掉 MidMid(string,start,length)从string字符串的start字符开始取得length长度的字符串，如果省略第三个参数表示从start字符开始到字符串结尾的字符串 LeftLeft(string,length)从string字符串的左边取得length长度的字符串 RightRight(string,length)从string字符串的右边取得length长度的字符串 LCaseLCase(string)将string字符串里的所有大写字母转化为小写字母 UCaseUCase(string)将string字符串里的所有大写字母转化为大写字母 StrCompStrComp(string1,string2[，compare])返回string1字符串与string2字符串的比较结果，如果两个字符串相同，则返回0，如果小于则返回-1，如果大于则返回1 InStrInStr(string1,string2[,compare])返回string1字符串在string2字符串中第一次出现的位置 SplitSplit(string1,delimiter[,count[,start]])将字符串根据delimiter拆分成一维数组，其中delimiter用于标识子字符串界限。如果省略，使用空格("")作为分隔符。

C语言32个字符的定义

C语言32个字符的定义 2009-03-01 21:49 auto ：声明自动变量一般不使用 double ：声明双精度变量或函数 int：声明整型变量或函数 struct：声明结构体变量或函数 break：跳出当前循环 else ：条件语句否定分支（与 if 连用） long ：声明长整型变量或函数 switch :用于开关语句 case：开关语句分支 enum ：声明枚举类型 register：声明积存器变量 typedef：用以给数据类型取别名（当然还有其他作用） char ：声明字符型变量或函数 extern：声明变量是在其他文件正声明（也可以看做是引用变量） return ：子程序返回语句（可以带参数，也看不带参数） union：声明联合数据类型 const ：声明只读变量 float：声明浮点型变量或函数 short ：声明短整型变量或函数 unsigned：声明无符号类型变量或函数 continue：结束当前循环，开始下一轮循环 for：一种循环语句(可意会不可言传） signed：生命有符号类型变量或函数 void ：声明函数无返回值或无参数，声明无类型指针（基本上就这三个作用）default：开关语句中的“其他”分支 goto：无条件跳转语句 sizeof：计算数据类型长度 volatile：说明变量在程序执行中可被隐含地改变 do ：循环语句的循环体 while ：循环语句的循环条件 static ：声明静态变量 if:条件语句

转义字符的定义 SqlServer中Sql语句的转义字符的使用(Escape charator) WHERE ProductName LIKE '[2005]%' 如果这样，他就找第一个字符是2,0,5之中的任何一个，而实际上不是这样的 这个时候就应该用转义，ESCAPE 关键字 WHERE ProductName LIKE '/[2005/]%' ESCAPE '/' /后边的都不是通配符了，而是一个字符。 like '%50/%%' ESCAPE '/' % _ [] [^] NOT LIKE '415%' 二、VBScript 转义字符（Escape Character) 目前我所知道的VBScript需要的转义字符就只有一个“"”（西文双引号）。在字符串中如果需要输入“"”，会和程序中的“"”混淆。因此我们在字符串内遇到要用“"”时一般用“""”（两个西文双引号）或“'”（一个西文单引号）替换。^AF 我们的第一个VBScript做的是一个E-Mail地址，我们现在用HTML语法让它带有链接。 一、VBScript 常量（Constant）

C语言字符串的输入和输出

C语言字符串的输入和输出 字符串的输入和输出 %c人为加入\0进行输入输出 %s直接输入输出 *输入输出字符串时字符数组应有足够的存储空间，指针变量作为输入项时，指针必须已经指向确切的、足够大的存储空间 %s的使用 scanf("%s",地址值) 地址值:字符数组名、字符指针、字符数组元素的地址 例:char str[15]; scanf("%s",str); abc123 1.不读入空格和回车,从空格处结束 2.输入字符串长度超过字符数组元素个数，不报错 3.当输入项为字符指针时，指针必须已指向确定的有足够空间的连续 存储单元 4.当为数组元素地址时，从此元素地址开始存放 2.printf("%s",地址值) 输出时遇到第一个'\0'为止 3.gets和puts函数 开头必须stdio.h #include"stdio.h"

1.gets(地址值) 地址值:字符数组名、字符指针、字符数组元素的地址 4.当为数组元素地址时，从此元素地址开始存放 5.printf("%s",地址值) 输出时遇到第一个'\0'为止 6.gets和puts函数 开头必须stdio.h #include"stdio.h" 1.gets(地址值) 地址值:字符数组名、字符指针、字符数组元素的地址 7.例: char str[10]; gets(str); 包括空格符 8. 2.puts(字符串起始地址) 遇第一个'\0'结束,自动加入换行符 9.字符串数组:数组中每个元素都是一个存放字符串的数组 可以将一个二维数组看作是字符串数组 10.char ca[3][5]={"A","BB","CCC"}; A\0 B B\0 C C C\0 字符型指针数组 char*pa[3]={"a","bb","ccc"}; pa[0]pa[1]pa[2] 可以重新赋值gets(pa[2]);

C语言字符串操作总结大全(超详细)

C语言字符串操作总结大全(超详细) 1）字符串操作 strcpy(p, p1) 复制字符串 strncpy(p, p1, n) 复制指定长度字符串 strcat(p, p1) 附加字符串 strncat(p, p1, n) 附加指定长度字符串 strlen(p) 取字符串长度 strcmp(p, p1) 比较字符串 strcasecmp忽略大小写比较字符串 strncmp(p, p1, n) 比较指定长度字符串 strchr(p, c) 在字符串中查找指定字符 strrchr(p, c) 在字符串中反向查找 strstr(p, p1) 查找字符串 strpbrk(p, p1) 以目标字符串的所有字符作为集合，在当前字符串查找该集合的任一元素strspn(p, p1) 以目标字符串的所有字符作为集合，在当前字符串查找不属于该集合的任一元素的偏移 strcspn(p, p1) 以目标字符串的所有字符作为集合，在当前字符串查找属于该集合的任一元素的偏移 * 具有指定长度的字符串处理函数在已处理的字符串之后填补零结尾符 2）字符串到数值类型的转换 strtod(p, ppend) 从字符串p 中转换double 类型数值，并将后续的字符串指针存储到ppend 指向的char* 类型存储。 strtol(p, ppend, base) 从字符串p 中转换long 类型整型数值，base 显式设置转换的整型进制，设置为0 以根据特定格式判断所用进制，0x, 0X 前缀以解释为十六进制格式整型，0 前缀以解释为八进制格式整型 atoi(p) 字符串转换到int 整型 atof(p) 字符串转换到double 符点数 atol(p) 字符串转换到long 整型 3）字符检查 isalpha() 检查是否为字母字符 isupper() 检查是否为大写字母字符 islower() 检查是否为小写字母字符 isdigit() 检查是否为数字 isxdigit() 检查是否为十六进制数字表示的有效字符 isspace() 检查是否为空格类型字符 iscntrl() 检查是否为控制字符 ispunct() 检查是否为标点符号 isalnum() 检查是否为字母和数字 isprint() 检查是否是可打印字符 isgraph() 检查是否是图形字符，等效于isalnum() | ispunct()

Linux下常用C语言字符串操作函数

Linux下常用C语言字符串操作函数 stroul， strdup snprintf() atio C中常用字符串操作函数 #include size_t strlen(const char *s) 测量字符串长度s的实际长度。 例如s[20]="abc",那么strlen(s)的结果是3，而不是20.这就是实际长度 char *strcat(const char *s1, const *s2) 将字符串s2连接到s1的尾部。从s1的\0开始。 int strcmp(const *s1,const *s2) 比较s1和s2。 s1 = s2的时候返回值=0 s1 < s2的时候返回至<0 s1 > s2的时候返回值>0 char *strchr(const char *s, char c); 返回s中首次出现C的位置的指针。如果s中不存在c则返回NULL char *strrchr(const char *s, char c );返回s中最后一次出现c的位置的指针。如果没有，则返回0 char *strstr(const char *haystack, const char *needle);返回haystack中needle字符串首次出现的位置的指针（不比较结束符NULL）。若果没找到则返回NULL 限定长度的比较，拷贝和追加函数 int strncmp(char *s1, const char *s2, size_t n);(这些都是针对字符串的前n个字符来操作的) char *strncpy(char *dest, const char *src, size_t n); char *strncat(char *dest, const char *src, size_t n); char *strdup(char *s)返回指向被复制的字符串的指针，所需空间由malloc()分配而且需要free释放空间 int atoi(const char *nptr);将字符串转换成整型数

各种C语言字符串操作,str....

字符串操作 strchr 原型：char *strchr(const char* _Str,int _Val) char *strchr(char* _Str,int _Ch) 头文件：#include 功能：查找字符串s中首次出现字符c的位置 说明：返回首次出现c的位置的指针，返回的地址是被查找字符串指针开始的第一个与Val相同字符的指针，如果s中不存在c则返回NULL。 返回值：成功则返回要查找字符第一次出现的位置，失败返回NULL strcmp 原型：extern int strcmp(const char *s1,const char *s2); C/C++函数，比较两个字符串 设这两个字符串为str1，str2， 若str1==str2，则返回零； 若str1>str2，则返回正数； 若str1

对于设置了LC_COLLATE语言环境的情况下，则根据LC_COLLATE设置的语言排序方式进行比较。例如：汉字，根据拼音进行比较。 strcpy 原型：char *strcpy(char *dest, const char *src); 头文件：#include 和#include 功能：把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间 说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。 返回指向dest的指针。 strcspn 原型：size_t strcspn(const char *s, const char *reject); 头文件：#include 功能：顺序在字符串s1中搜寻与s2中字符的第一个相同字符，包括结束符NULL，返回这个字符在S1中第一次出现的位置。 说明：（返回字符串s1中第一个在s2中出现的字符在s1中的下标值，亦即在s1中出现而s2中没有出现的子串的长度。） strdup 原型：char *strdup(const char *s); 功能: 将串拷贝到新建的位置处 strdup()在内部调用了malloc()为变量分配内存，不需要使用返回的字符串时，需要用free()释放相应的内存空间，否则会造成内存泄漏。 返回一个指针,指向为复制字符串分配的空间;如果分配空间失败,则返回NULL值。

linuxc字符串操作的基本使用

Linux C 字符串操作的基本使用 Linux C 字符串操作的基本使用 所属头文件:<string.h> 0、获取字符串长度:int strlen(char *s) int strlen(char *s)函数说明：此函数用于获取s的长度，不包括'\0'注：切记最好保证s的尾部是'\0'，strlen函数读到'\0'会自动停止然后统计字符数 返回值：字符数1、查找指定的字符:index函数,rindex函数,strchr函数strrchr(其中index函数和strchr函数基本相同,rindex函数和strchr函数相同）（1）char *index(const char* s, char c) char *strchr(const char* s, char c) 函数说明:index函数用于查找字符串s中第一个出现c字符的地址，然后将该字符的地址返回.strchr函数与index相似返回值：若找到指定到字符则返回该字符的地址，否则返回0 举例： char s[] = "abcdeabcde"; char *sdest = NULL; sdest = index(s,'d'); printf("sdest: %s\n",sdest); 输出结果：sdest: deabcde

(2)char *rindex(const char* s, char c) char *strrchr(const char* s, char c) 函数说明:类似于index函数，但是他是从字符串开始查找字符c，并返回从字符串尾部开始第一个符合条件的字符的地址(strrchr与rindex相似) 返回值：同index一样 举例: char s[] = "abcdeabcde"; char *sdest = NULL; sdest = rindex(s,'d'); printf("sdest: %s\n",sdest); 输出结果:sdest: de2、查找满足条件字符串中任意一个字符：strpbrk函数char *strpbrk(const char *s, const char *accept) 函数说明:查找s字符串第一个符合accept字符串中任意一个字符的字符的地址 返回值:符合条件的字符的地址 举例： char s[] = "abcdefgefgbe"; char t[] = "omgf"; char *d = NULL;

C语言字符串模式匹配

数据结构面试之十四——字符串的模式匹配 题注：《面试宝典》有相关习题，但思路相对不清晰，排版有错误，作者对此参考相关书籍和自己观点进行了重写，供大家参考。 十四、字符串的模式匹配 1. 模式匹配定义——子串的定位操作称为串的模式匹配。 2. 普通字符串匹配BF算法（Brute Force 算法，即蛮力算法） 【算法思想】： 第（1）步；从主串S的第pos个字符和模式的第一个字符进行比较之，若相等，则继续逐个比较后续字符；否则从主串的下一个字符起再重新和模式串的字符比较之。 第（2）步骤；依次类推，直至模式T中的每一个字符依次和主串S中的一个连续的字符序列相等，则称匹配成功；函数值为和模式T中第一个字符相等的字符在主串S中的序号，否则称为匹配不成功，函数值为0。 比如对于主串S=”abacababc”; 模式串T=”abab”; 匹配成功，返回4。 对于主串S=”abcabcabaac”; 模式串T=”abab”; 匹配不成功，返回0。 【算法实现】： //普通字符串匹配算法的实现 int Index(char* strS, char* strT, int pos) { //返回strT在strS中第pos个字符后出现的位置。 int i = pos; int j = 0; int k = 0; int lens = strlen(strS);

int lent = strlen(strT); while(i < lens && j < lent) { if(strS[i+k] == strT[j]) { ++j; //模式串跳步 ++k; //主串(内)跳步 } else { i = i+1; j=0; //指针回溯，下一个首位字符 k=0; } }//end i if(j >= lent) { return i; } else { return 0; } }//end [算法时间复杂度]：设主串长度为m,模式串的长度为n。一般情况下n

C常用字符串函数

C常用字符串函数 平时对字符串的操作的是很多的，了解下常用的字符串函数会使c 编程变得很快捷！这里适当整理一下，方便以后参考。使用时，会用到大量指针的操作，注意加头文件： #include 一、str 系列 1.strtok extern char *strtok( char *s, const char *delim ); 功能：分解字符串为一组标记串。s为要分解的字符串，delim为分隔符字符串。 说明：strtok()用来将字符串分割成一个个片段。当strtok()在参数s的字符串中发现到参数delim的分割字符时则会将该字符改为\0 字符。在第一次调用时，strtok()必需给予参数s字符串，往后的调用则将参数s设置成NULL。每次调用成功则返回被分割出片段的指针。当没有被分割的串时则返回NULL。所有delim中包含的字符都会被滤掉，并将被滤掉的地方设为一处分割的节点。 举例： /* strtok example */ #include #include int main (void) { char str[] = "- This, a sample string."; char *pch; printf("Splitting string \"%s\" into tokens:\n", str); pch = strtok(str," ,.-"); while (pch != NULL)

{ printf("%s\n", pch); pch = strtok(NULL, " ,.-"); } printf("at the end: %s", str); return0; } Splitting string"- This, a sample string." into tokens: This a sample string the end: - This 注：strtok函数会破坏被分解字符串的完整，调用前和调用后的s已经不一样了。另外貌似制表符\t 无法充当分割字符。 2.strstr char * strstr( const char * str1, const char * str2 ); 功能：从字符串str1 中寻找str2 第一次出现的位置（不比较结束符NULL)，如果没找到则返回NULL。 举例： /* strstr example */ #include #include int main () { char str[] = "This is a s i mple string"; char *pch; pch = strstr(str, "s i mple"); strncpy(pch, "s a mple", 6); puts(pch);

C语言字符串处理的库函数

C语言字符串处理的库函数 使用C语言字符串处理的库函数，务必包含头文件string.h，即#include 1、比较字符串大小函数 ---strcasecmp 忽略大小写---strcasecmp 1）忽略大小写 函数原型：int strcasecmp(const char*s1,const char*s2); 函数说明：用来比较参数s1和s2字符串，比较时会自动忽略大小写的差异 2）忽略大小写—stricmp 函数原型：int stricmp(char*str1,char*str2); 函数说明：以大小写不敏感方式比较两个串 3）不忽略大小写—strcmp 函数原型：int strcmp(char*str1,char*str2); 函数说明：通过比较字串中各个字符的ASCII码，来比较参数Str1和Str2字符串，比较时考虑字符的大小写。 4）比较一部分—strncmpi

函数原型：int strncmpi(char*str1,char*str2,unsigned maxlen); 函数说明：比较字符串str1和str2的前maxlen个字符 ---memcmp 5）内存区域比较 ）内存区域比较---memcmp 函数原型：int memcmp(void*buf1,void*buf2,unsigned int count)函数说明：比较内存区域buf1和buf2的前count个字节。Void*是指任何类型的指针。 ）内存区域部分比较----memicmp Void*是指任何类型的指针。 6）内存区域部分比较 函数原型：int memicmp(void*buf1,void*buf2,unsigned int count)函数说明：比较内存区域buf1和buf2的前count个字节，但不区分大小写。 以上比较函数的返回值：若参数1中字符串和参数中2字符串相同则返回0； 若参数1中字符串长度大于参数2中字符串长度则返回大于0的值； 若参数1中字符串长度小于参数2中

C_字符串处理：截取、替换、移除

C#字符串处理系列之——裁剪，替换，移除 问题1：我想删除字符串中指定的字符。 解答：技巧性的方法，用Replace（）。 例如：string str = " how are you ! "。现在我们删除它中间的空格，则str = str.Replace（" ",""）。懂了吧，把要删除的字符替换成""就OK了！ 问题2：我想删除字符串开头和结尾的空格。 解答：用Trim（）系列。Trim（char a）删除字符串开头和结尾的字符a，TrimEnd（char a）删除结尾的，TrimStart(char a )删除开头的。 若不指定a，即Trim（），TrimEnd（），TrimStart（）则表示删除空格。 问题3：我想移除某段字符串。 解答：用Remove(int n1,int n2),其中n1指索引位置，n2指长度。 例如：string str = "how are you ! "，str1 = str.Remove(1,2),则str1 = "h are you ! "。 问题4：我想删除字符串中一系列的字符，难道要用一系列的Replace或者用一系列的Trim吗？ 解答：1.如果要移除字符串开头或者结尾处的一系列字符，那么可以使用到ToCharArray （），因为 Trim()系列提供了两种方法，Trim(char a),Trim(char [])。 例如：string str = "how are you ! "，现在我想删除str开头和结尾的所有'h','!','u','a'那么我可以这样写 str1 = str.Trim("h!au".ToCharArray(),""); 2.如果要删除字串中一系列的字符，无论这些字符在开头，结尾，还是在中间，都一律删除，用个for循环就行了。 还是上例。我们这样写，string c = "h!ua"; for(int i =0;i

C语言字符串操作函数

strtok()—字符串分割函数 相关函数：index, memchr, rindex, strpbrk, strsep, strspn, strstr 头文件：#include 定义函数：char * strtok(char *s, const char *delim); 函数说明：strtok()用来将字符串分割成一个个片段. 参数s 指向欲分割的字符串, 参数delim 则为分割字符串,当strtok()在参数s 的字符串中发现到参数delim 的分割字符时则会将该字符改为\0 字符. 在第一次调用时,strtok()必需给予参数s 字符串, 往后的调用则将参数s 设置成NULL. 每次调用成功则返回下一个分割后的字符串指针. 返回值：返回下一个分割后的字符串指针, 如果已无从分割则返回NULL. 范例 #include main() { char s[] = "ab-cd : ef;gh :i-jkl;mnop;qrs-tu: vwx-y;z"; char *delim = "-: "; char *p; printf("%s ", strtok(s, delim)); while((p = strtok(NULL, delim))) printf("%s ", p); printf("\n"); } 执行结果： ab cd ef;gh i jkl;mnop;qrs tu vwx y;z //－与:字符已经被\0 字符取代 strstr()—字符串查找函数 相关函数：index, memchr, rindex, strchr, strpbrk, strsep, strspn, strtok 头文件：#include 定义函数：char *strstr(const char *haystack, const char * needle); 函数说明：strstr()会从字符串haystack 中搜寻字符串needle, 并将第一次出现的地址返回. 返回值：返回指定字符串第一次出现的地址, 否则返回0.

C语言中的转义字符

C语言中的转义字符 转义字符是C语言中表示字符的一种特殊形式。通常使用转义字符表示ASCII码字符集中不可打印的控制字符和特定功能的字符，如用于表示字符常量的单撇号（'），用于表示字符串常量的双撇号（"）和反斜杠（\）等。转义字符用反斜杠\后面跟一个字符或一个八进制或十六进制数表示。表2-4给出了C语言中常用的转义字符。 字符常量中使用单引号和反斜杠以及字符常量中使用双引号和反斜杠时，都必须使用转义字符表示，即在这些字符前加上反斜杠。 在C程序中使用转义字符\ddd或者\xhh可以方便灵活地表示任意字符。\ddd为斜杠后面跟三位八进制数，该三位八进制数的值即为对应的八进制ASCII码值。\x后面跟两位十六进制数，该两位十六进制数为对应字符的十六进制ASCII码值。 使用转义字符时需要注意以下问题：

1)、转义字符中只能使用小写字母，每个转义字符只能看作一个字符。 2)、\v垂直制表和\f换页符对屏幕没有任何影响，但会影响打印机执行响应操作。 3)、在C程序中，使用不可打印字符时，通常用转义字符表示。 下面这个例子演示了\a、\b、\t、\r，以及\n的作用。其中\b，\t和\r的概念可以追溯到电脑仍然使用打字机作为输出设备的时候，所以对于现代的一些电脑来说，它们可能不起作用。在某些麦金托什机（Macintosh）上，它们的作用就和我们下面所说的不一样。首先请认真看一下以下程序，然后编译运行一下，看看运行结果和您想象的是否一样，然后再看后面的详细解说。 /*esc_sq.c--使用转义字符*/ #include int main(void) { float height; printf("\aPlease enter your height:_____ cm\b\b\b\b\b\b\b\b");

C语言字符串函数大全

C语言字符串函数大全 函数名: stpcpy 功 能: 拷贝一个字符串到另一个 函数名: strcat 功 能: 字符串拼接函数 函数名: strcmp 功 能: 串比较 函数名: strchr 功 能: 在一个串中查找给定字符的第一个匹配之处 函数名: strncmpi 功 能: 将一个串中的一部分与另一个串比较, 不管大小写 函数名: strcpy 功 能: 串拷贝 函数名: strcspn 功 能: 在串中查找第一个给定字符集内容的段 函数名: stricmp 功 能: 以大小写不敏感方式比较两个串 函数名: strerror 功 能: 返回指向错误信息字符串的指针 函数名: strcmpi 功 能: 将一个串与另一个比较, 不管大小写 函数名: strncmp 功 能: 串比较 int strncmp(char *str1, char *str2, int maxlen); 函数名: strncmpi 功 能: 把串中的一部分与另一串中的一部分比较, 不管大小写 函数名: strnset 功 能: 将一个串中的所有字符都设为指定字符 函数名: strrchr 功 能: 在串中查找指定字符的最后一个出现 函数名: strrev 功 能: 串倒转 用 法: char *strrev(char *str); 函数名: strspn 功 能: 在串中查找指定字符集的子集的第一次出现 函数名: strtol 功 能: 将串转换为长整数 函数名: strstr 功 能: 在串中查找指定字符串的第一次出现 函数名: strtod 功 能: 将字符串转换为double型值 函数名: strupr 功 能: 将串中的小写字母转换为大写字母 函数名: strtok 功 能: 查找由在第二个串中指定的分界符分隔开的单词 函数名: swab 功 能: 交换字节 -------------------------------------------------------------------------------------------- 函数名: stpcpy 功 能: 拷贝一个字符串到另一个 用 法: char *stpcpy(char *destin, char *source); 程序例: #include #include int main(void) { char string[10]; char *str1 = "abcdefghi"; stpcpy(string, str1); printf("%s\n", string); return 0; } --------------------------------------------------------------------------------- 函数名: strcat 功 能: 字符串拼接函数

c语言字符串处理函数

C语言字符串处理函数 一、函数 1、字符串的长度strlen() 说明： 返回s的长度，不包括结束符NULL。strlen(char*)函数求的是字符的实际长度，它求得方法是从开始到遇到第一个'\0',如果你只定义没有给它赋初值，这个结果是不定的，它会从首地址一直找下去，直到遇到'\0'停止。 与sizeof()的区别： A、char ss[10]=""; sizeof(ss) = 10; strlen(ss) = 0; B、char *aa = "asd"; sizeof(aa) = 4; strlen(aa) = 3; C、sizeof是在编译期间计算其值； Strlen在运行期间计算返回值 D、sizeof是操作符（关键字），strlen是函数。 E、.sizeof后如果是类型必须加括弧，如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。 F、当适用了于一个结构类型时或变量，sizeof 返回实际的大小， 当适用一静态地空间数组，sizeof 归还全部数组的尺寸。 sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸 自定义strlen() int strlen(const char *str) { assert(str != NULL); int len = 0; while((*str++) != '\0') len++; return len; } 2、比较字符串大小函数 区分大小写：strcmp() （1）函数原型：int strcmp(char*str1,char*str2); 函数说明：通过比较字串中各个字符的ASCII码，来比较参数Str1和Str2字符串，比较时考虑字符的大小写。 返回值：比较字符串str1和str2的大小，如果str1小于str2，返回值就<0，反之如果str1大于str2，返回值就>0，如果str1等于str2，返回值就=0， 自定义实现： int strcmp (char* a,char* b) { int k=0; for( ; a[k] && b[k] && (a[k]==b[k]) ; k++); return(a[k]-b[k]); } strncmp() (2) 函数原型：int strncmp(char *str1, char *str2, int maxlen); 函数说明：比较字符串str1和str2的前maxlen个字符 返回值：比较字符串str1和str2的大小， 如果str1小于str2，返回值就<0； 反之如果str1大于str2，返回值就>0； 如果str1等于str2，返回值就=0； maxlen指的是str1与str2的比较的字符数。 自定义实现：