1 字符串提取数字

string类的构造函数:
string(const char *s); //用c字符串s初始化
string(int n,char c); //用n个字符c初始化
此外,string类还协助暗中同意构造函数和复制构造函数,如string s1;string s2="hello";都以合情合理的写法。当组织的string太长而不能表明时会抛出length_error异常

在c语言中,字符串是用字符数组来积攒的(并不像c++可能java等语言中有独立的string类型卡塔 尔(英语:State of Qatar),

2 将三个字符串归总为一个字符串而且输出,用指针实现

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为起始位置的字符数组中,返回实际拷贝的数目

寄存时在字符串的结尾扩充了象征字符串甘休的申明字符’\0′

3 延续字符串的假名的总计

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填充不足的部分

字符串即使是按组成字符串的后生可畏一字符存款和储蓄在数组的各样要素中,但其往往代表五个全体音讯,将其分手成单个字符是未有意义的,所现在往也是将其当做一个安然无恙举行管理。

4 删除 包蕴的字符串

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

上边就多少个地点对字符串举办介绍。

5 替换字符串

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迭代器之间的部分赋给字符串

1. 字符串数组的概念与使用

注:要是 对 *char类型的参数举行改变也许是 *result结果开展
重返值时,记得要 设置三个标识的指针用来回到,就像 对链表的回来要标记头结点*head的任务同样的道理。

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之间的部分连接到当前字符串的结尾

#include “stdio.h”

======================================================================================

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

void main()

1 字符串提取数字

string的子串:
string substr(int pos = 0,int n = npos) const;//返回pos开始的n个字符组成的字符串

{

找到 0-9的字符,count++,在内部循环直到蒙受不是数字的字符

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

char my_string[15];

int take_num( const char *src,int outArr[] )
{
    assert(src!=NULL);
    int count=0,tmp;
    while(*src!='')
    {
        tmp=0;
        if(*src>='0'&&*src<='9')
        {
            while(*src>='0'&&*src<='9')
            {
                tmp=tmp*10+*src-'0';
                src++;
            }

            outArr[count]=tmp;
            count++;
        }
        src++;
    }
    printArrray(outArr,count);
    return count;
}

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的值

printf(“input a string:”);

2 将七个字符串合併为三个字符串並且输出,用指针完毕

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的值

scanf(“%s”,my_string);

变迁新的字符串result—使用二个address记录再次来到的地方,相同的时候在复制完成后拉长’’

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

printf(“%s”,my_string);

const char * mergeString( const char *str1,const char *str2 )
{
    if(str1==NULL) return (char*)str2;
    if(str2==NULL) return (char*)str1;
    char *result,*address;
    result=new char[strlen(str1)+strlen(str2)+1];    //每生成一个结果,相应的加上有关返回地址的东西。
    address=result;
    /*cout<<str1<<str2<<endl;*/
    while(*str1!='')
    {
        *result++=*str1++;
    }
    while(*str2!='')
    {
        *result++=*str2++;
    }
    *result='';
    cout<<address<<endl;
    return address;
}

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

}

3 一而再三番五次字符串的字母的计算

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;

输入是abc124a时输入输出如下表示:

void countString( const char *str )
{
    assert(str!=NULL);
    /*int *a=new int[52];*/
    int a[52]={0};
    while(*str!='')
    {
        a[*str-'A']++;
        str++;
    }
    for(int i=0;i<52;i++)
    {
        if(a[i]!=0)
            cout<<char(i+'A')<<a[i];
    }
}

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相似,只不过是从后向前查找

input a string:abc124a

4 删除 包括的字符串

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)之间的字符串

abc124a

主要就是:tmp被赋值与
删除字符串的长短,用于字符串相配strcmp卡塔尔国,找到就能够管理result,count大概是
src+=n个单位卡塔尔
,其他意况一向赋值正是了

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

当输入是123 abc时输入输出如下表示:

int delete_substring( const char *src,const char *substring ,char *result )
{
    assert(src!=NULL&&substring!=NULL);
    int count=0;
    char *tmp=new char[strlen(substring)+1];   //标记是否含有 substring。
    char *pCpy=result;
    while(*src!='')
    {
        if(*src==*substring)      //这里也是可以直接 strncpy(tmp,src,strlen(substring)); 然后进行判断的
        {
            strncpy(tmp,src,strlen(substring));
            *(tmp+strlen(substring))='';
            if(strcmp(substring,tmp)==0)
            {
                // 找到了,在这里进行操作。核心)
                count++;
                cout<<count<<endl;
                src+=strlen(substring);
            }
            else
            {
                *pCpy=*src;
                pCpy++;
                src++;
            }
        }
        else
        {
            *pCpy=*src;
            pCpy++;
            src++;
        }
    }
    *pCpy=''; //新的字符串,加上''标志了
    free(tmp);
    cout<<"处理后的字符串是:"<<result<<"  删除的个数是"<<count<<endl;
    return count;
}

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

input a string:123 abc

5 替换字符串

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实现

123

体贴正是:tmp被赋值与
删除字符串的长度,用于字符串相配strcmp卡塔 尔(英语:State of Qatar),找到就能够管理result,count可能是
src+=n个单位卡塔尔国,其他情况一向赋值就是了。

字符串流处理:
经过定义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++卡塔尔

小心:把叁个字符数组看成字符串后,可以直接行使%s来输入输出,后边一贯动用数组名。

1、比较字符串大小函数
1卡塔 尔(阿拉伯语:قطر‎ 忽视大小写—strcasecmp
函数原型:int strcasecmp (const char *s1, const char *s2);
函数表达:用来比较参数s1和s2字符串,相比时会自动忽视大小写的异样
2卡塔 尔(英语:State of Qatar)忽视大小写—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个字节,但不区分轻重缓急写。
以上相比函数的重临值:若参数第11中学字符串和参数中2字符串相通用准则再次回到0;
若参数第11中学字符串长度超过参数第22中学字符串长度则赶回大于0 的值;
若参数1中字符串 长度小于参数第22中学字符串 长度则赶回小于0的值。
2、从字符串中领取子串
1卡塔 尔(英语:State of Qatar) 提取子串–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(’’卡塔 尔(英语:State of Qatar)来替换直到找遍全体字符串。
再次来到值:从s开始初步的多个个被划分的串。当未有被分割的串时则赶回NULL。
富有delim中含有的字符都会被滤掉,并将被滤掉的地点设为后生可畏处分割的节点。
举例:

用%s读入时,表示需求读入叁个字符串到字符数组中,遇到第一个空格或回车,读入即停止。

// 1 找到第一个替换的位置: 2 tmp 3部分:之前的替换-old换成new-连接上后面的内容  3 tmp替换当前的字符串,循环
// 1 abcddfabg (ab换成xyz)        2 1-xyz-cddfabg  3 下一轮的循环。???
char * replaceString( char *src,const char *oldstr,const char *newstr )
{
    assert(src&&oldstr&&newstr);
    int lenstrlen(src);
     int lenold=strlen(oldstr);
    int lennew=strlen(newstr);
    char *result,*tmp,*markNew;
    result=new char[lennew>lenold? lensrc/lenold*lennew+1:lensrc];  //最大的空间内存:关键点
    char *fanhui=result;                                    //加上一个返回的指针的地址,必须的呀。
    tmp=new char[lenold+1];
    cout<<src<<endl;
    while(*src!='')
    {
        if(*src==*oldstr)
        {
            strncpy(tmp,src,lenold);
            tmp[lenold]='';
            if(strcmp(tmp,oldstr)==0)
            {
                //字符串替换 就在这里了,同时 遍历指针移动lenold。 同样的可以在这里 得到替换的次数。
                markNew=(char*)newstr;
                while(*markNew!='')
                {
                    *result++=*markNew++;
                }
                src+lenold;
             }
            else
            {
                *result++=*src++;
            }
        }
        else
        {
            *result++=*src++;
        }
    }
    *result='';
    cout<<fanhui<<endl;
    return fanhui;
    //assert(src&&oldstr&&newstr);
    //char *pStr=src;
    //char *findLocation;
    //findLocation=strstr(pStr,oldstr);
    //cout<<findLocation<<endl;
    //while(findLocation!=NULL)
    //{
    //  char *tmp = (char*)malloc(strlen(pStr) + (strlen(newstr) - strlen(oldstr)) +1);
    //  strncpy(tmp, pStr, findLocation-pStr);
    //  tmp[findLocation-src] = '';
    //  strcat(tmp, newstr);
    //  strcat(tmp, findLocation+strlen(oldstr));
    //  findLocation=strstr(tmp,oldstr);
    //  cout<<findLocation<<endl;
    //  cout<<tmp<<endl;
    //  pStr = strdup(tmp);
    //  free(tmp);
    //  //strcpy(pStr,tmp);       //拷贝,但是内存不足:以原先的字符串要长一些怎么把???这个有关内存释放的老是出现问题。
    //}
    //cout<<pStr<<endl;
    //return pStr;
}
#include <string.h>
#include <stdio.h>
int main(){
    char *s="Golden Global View";
    char *d=" ";
    char *p;
    p=strtok(s,d);
    while(p){
       printf("%sn",p);
       strtok(NULL,d);
    }
    return 0;
}

读入时还必要特别注意的是概念的字符数组的尺寸应该要超过读入数据的长短。

测量检验代码:

输出:Golden
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(卡塔 尔(英语:State of Qatar)分配且能够有free(卡塔 尔(阿拉伯语:قطر‎释放。
3卡塔 尔(英语:State of Qatar) 内部存款和储蓄器空间复制–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结尾处的’’)并添加’’
2)部分连接–strncat
函数原型: char* strncat(char*dest,char*src,int n);
函数表达:把src所指字符串的前n个字符加多到dest结尾处(覆盖dest结尾处的’’)并添加’’’.
重回值:再次回到指向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卡塔 尔(英语:State of Qatar)搜所现字符–strcspn
函数原型:int strcspn(char*src,char*find)
函数说明:在字符串src中追寻find中所现身的字符
再次来到值:重回第二个冒出的字符在src中的下标值,即src中现身而不在find中现身的字串的长度。
举例:

用%s输出时,要注意的是出口的是字符串的实在尺寸的那多少个字符,并不是出口定义时的字符数组的长度。如:

char *str1="abcdabac";
    char *str2="ab";
    char *result=new char[strlen(str1)+1];
    delete_substring(str1,str2,result);
    char *strin="af52d78d56dd89d";
    int  *outArray=new int[strlen(strin)];
    //int  outArray[]=new int[strlen(strin)];      //错误的,new返回的是 *int类型的
    take_num(strin,outArray);
    char *srcstr="22abcdabokabhaha";
    char *newstr="xyz";
    char *oldstr="ab";
    replaceString(srcstr,oldstr,newstr);
    /*char *str1="nihao";
    char *str2="xyz";
    mergeString(str1,str2);*/
    char *str="aaabbbbDDdjingianigndai";
    countString(str);
#include <string.h>
#include <stdio.h>
int main(){
    char *s="Golden Global View";
    char *r="new";
    int n;
    n=strcspn(s,r);
    printf("The first char both in s1 and s2 is: %c",s[n]);
   return 0;
}

#include “stdio.h”

字符串提取数字 2
将三个字符串归拢为二个字符串并且输出,用指针达成 3
三翻五次字符串的字母的总括 4 删除 包括的字符串 5 替换字符串…

输出:The first char both in s1 and s2 is :e
4)相配任一字符–strpbrk
函数原型:char*strpbrk(char*s1,char*s2)
函数表明:在字符串S第11中学找出字符串S第22中学任何三个字符相相配的第贰个字符的职位,空字符不包涵在内。
重回值:重临指向S第11中学率先个相相称的字符的指针,若无相称字符则重回空指针。
举例:

void main()

#include <stdio.h>
#include <string.h>
int main(){
    char *s1="Welcome To Beijing";
    char *s2="BIT";
    char *p;
    p=strpbrk(s1,s2);
    if(p)
        printf("%sn",p);
    else printf("Not Found!n");
    return 0;
}

{

输出:To Beijing
6、别的函数
1卡塔 尔(英语:State of Qatar)全部转成大写—strupr
函数原型:char*strupr(char*src)
函数表达:将字符串src调换来大写格局,只调换src中冒出的小写字母,不更正其余字符
再次回到值:再次来到指向src的指针。
2卡塔 尔(英语:State of Qatar)全部转成小写—strlwr
函数原型:char*strlwr(char*src)
函数表明:将字符串src调换来小写方式,只转换src中出现的大写字母,不转移别的字符
重临值:再次来到指向src的指针。
3卡塔 尔(阿拉伯语:قطر‎将字串逆向–strrev
函数原型:char*strrev(char*src)
函数表明:把字符串src的具备字符的逐意气风发颠倒过来(不富含NULL卡塔尔国
重临值:再次来到指向颠倒顺序后的字符串指针

char my_str[5];

int i;

my_str[4]=’K’;

printf(“input a string:”);

scanf(“%s”, my_str);

printf(“%s”, my_str);

}

输入输出如下:

input a string:2q

2q

本条事例中,

my_str[]数组的第多少个元素是’k’字符,可是读入这一个字符串时只用到了2个因素,即

my_str[0]=2

my_str[1]=q

而%s输出时只是输出了2q那三个字符,那么字符串输出是怎么精通截止了的呢?

此地会选用到八个私下认可的字符串结束标记字符’\0’,即那个时候读入时,会在终极自动抬高

my_str[2]=’\0’,所以输出时从字符串的头即0号成分即数组的首地址一贯输出到’\0’结束,并且这么些截至字符本人不会输出。

再有,

#include “stdio.h”

void main()

{

char my_str[30]=”abab adda”;

int i;

printf(“%s\n”,my_str);

for(i=0;i<30;i++)

{

printf(“%c”,my_str[i]);

}

}

输入输出如下:

abab adda

abab adda

亟待专心的是,这么些字符串中有个空格字符,会通常输出,不会截断。

相比较下边三个事例。利用%s输入。

#include “stdio.h”

void main()

{

char my_str[30];

scanf(“%s”,my_str);

printf(“%s”,my_str);

}

输入输出如下:

abab adda

abab

因为%s读入境遇空格就甘休了。

2.常用字符类型函数

字符类型函数分为两类:类型决断类函数和类型转变类函数。类型判别类函数是用来测量试验一个字符是还是不是归于某生机勃勃档期的顺序,如是不是为字母,数字等。

当字符归属函数所钦点的项目时,函数重回真值1,不然重临值0.

类型调换类函数蕴涵五个函数,三个是将字母字符由大写调换来小写,另多个是将字母字符由小写调换来大写。

常用的字符类型函数如下:(使用时,必要援用头文件  )

函数原型函数功效描述

int isalunm(int ch卡塔 尔(阿拉伯语:قطر‎检查ch是不是是字母或数字

int is阿尔法(int ch卡塔尔检查ch是不是是字母

int isdigit(int ch卡塔 尔(英语:State of Qatar)检查ch是不是是数字

int islower(int ch卡塔尔国检查ch是或不是是小写字母

int issupper(int ch卡塔尔国检查ch是还是不是是大写字母

int iscntrl(int ch卡塔尔检查ch是或不是是调控字母

int tolower(int ch卡塔尔国将大写字符ch转变来小写字符

int toupper(int ch卡塔 尔(英语:State of Qatar)将小写字符ch转变到大写字符

int isalunm(int ch卡塔 尔(阿拉伯语:قطر‎检查ch是还是不是是字母或数字

3.字符串操作函数。  要求援引头文件

先列出珍视的简单介绍,具体介绍见下文。

strtok()字符串分割函数

strstr()字符串查找函数

strspn()字符查找函数

strrchr()固定字符串中最终出现的钦定字符

strpbrk()一定字符串中首先个冒出的钦定字符

strncpy()复制字符串

strncat()字符串连接函数

strncasecmp()字符串相比较函数(忽略大小写)

strlen()字符串长度总括函数

strdup()复制字符串

strcspn()追寻字符串

strcpy()复制字符串

strcoll()字符串比较函数(按字符排列顺序)

strcmp()字符串相比函数(比较字符串)

strchr()字符串查找函数(重临第一遍现身字符的岗位)

strcat()连年字符串

strcasecmp()字符串相比函数(忽略大小写比较字符串)

rindex()字符串查找函数(重返最后贰回现身的岗位)

index()字符串查找函数(再次来到第三次面世的岗位)

toupper()字符串转变函数(小写转大写)

tolower()字符串转换函数(大写转小写)

toascii()将整数调换到合法的ASCII码字符

strtoul()将字符串调换来无符号长整型数

strtol()将字符串调换来长整型数

strtod()将字符串转变到浮点数

gcvt()将浮点型数调换为字符串(四舍五入)

atol()将字符串调换到长整型数

atoi()将字符串转变来整型数

atof()将字符串转变来浮点型数

void *memset(void *dest, int c, size_t count);

将dest后面count个字符置为字符c. 重临dest的值.

void *memmove(void *dest, const void *src, size_t count);

从src复制count字节的字符到dest. 假如src和dest出现重叠, 函数会自动管理.
重返dest的值.

void *memcpy(void *dest, const void *src, size_t count);

从src复制count字节的字符到dest. 与memmove效能相似,
只是不可能管理src和dest出现重叠. 重临dest的值.

void *memchr(const void *buf, int c, size_t count);

在buf后面count字节中索求第三回面世字符c之处.
找到了字符c恐怕已经研究了count个字节, 查找即截至.

操作成功则赶回buf中第壹次出现c的职位指针, 不然赶回NULL.

void *_memccpy(void *dest, const void *src, int c, size_t count);

从src复制0个或四个字节的字符到dest.
当字符c被复制可能count个字符被复制时, 复制结束.

只要字符c被复制, 函数重回那些字符后边紧挨三个字符地方的指针.
不然重返NULL.

int memcmp(const void *buf1, const void *buf2, size_t count);

比较buf1和buf2后边count个字节大小.

返回值< 0, 表示buf1小于buf2;

重返值为0, 表示buf1等于buf2;

返回值> 0, 表示buf1大于buf2.

int memicmp(const void *buf1, const void *buf2, size_t count);

相比buf1和buf2后面count个字节. 与memcmp不一样的是, 它不区分轻重缓急写.

重回值同上.

size_t strlen(const char *string);

拿到字符串长度, 字符串甘休符NULL不划算在内.

一向不再次来到值提示操作错误.

char *strrev(char *string);

将字符串string中的字符顺序颠倒过来. NULL结束符地方不改变.

再次回到调度后的字符串的指针.

char *_strupr(char *string);

将string中具有小写字母替换来对应的大写字母, 此外字符保持不改变.

归来调度后的字符串的指针.

char *_strlwr(char *string);

将string中有着大写字母替换到相应的小写字母, 此外字符保持不改变.

回去调解后的字符串的指针.

char *strchr(const char *string, int c);

查找字符c在字符串string中第三回现身的地点, NULL截至符也包罗在查找中.

归来八个指南针, 指向字符c在字符串string中第叁遍现身的岗位, 若无找到,
则再次回到NULL.

char *strrchr(const char *string, int c);

查找字符c在字符串string中最终贰遍面世的职责, 也正是对string举行反序寻觅,
包蕴NULL截止符.

归来贰个指针, 指向字符c在字符串string中最终一次面世之处, 若无找到,
则重返NULL.

char *strstr(const char *string, const char *strSearch);

在字符串string中追寻strSearch子串.

重返子串strSearch在string中第叁次出现岗位的指针.
若无找到子串strSearch, 则重回NULL. 假使子串strSearch为空白,
函数再次回到string值.

char *strdup(const char *strSource);

函数运营中会自身调用malloc函数为复制strSource字符串分配存款和储蓄空间,
然后再将strSource复制到分配到的上空中. 注意要及时放出那一个分配的空间.

归来一个指针, 指向为复制字符串分配的上空; 假诺分配空间失败,
则重回NULL值.

char *strcat(char *strDestination, const char *strSource);

将源串strSource加多到对象串strDestination后边,
并在拿到的新串前面加上NULL截至符.
源串strSource的字符会覆盖目的串strDestination后边的截止符NULL.
在字符串的复制或加上进程中平昔不溢出检查, 所以要保险指标串空间丰裕大.
不能够管理源串与指标串重叠的景况.

函数重临strDestination值.

char *strncat(char *strDestination, const char *strSource, size_t
count);

将源串strSource开始的count个字符增添到指标串strDest后.
源串strSource的字符会覆盖指标串strDestination前边的实现符NULL.
借使count大于源串长度, 则会用源串的长度值替换count值.
拿到的新串前边会活动抬高NULL截止符. 与strcat函数雷同,
本函数不能管理源串与对象串重叠的景况.

函数重回strDestination值.

char *strcpy(char *strDestination, const char *strSource);

复制源串strSource到对象串strDestination所钦命的职责, 饱含NULL甘休符.
不能够管理源串与对象串重叠的情状.

函数再次回到strDestination值.

char *strncpy(char *strDestination, const char *strSource, size_t
count);

将源串strSource起首的count个字符复制到指标串strDestination所钦命的地点.
若是count值小于或等于strSource串的长短, 不会自行增添NULL甘休符目的串中,
而count大于strSource串的长度时,
则将strSource用NULL甘休符填充补齐count个字符, 复制到目的串中.
不能够管理源串与对象串重叠的情状.

函数重回strDestination值.

char *strset(char *string, int c);

将string串的全体字符设置为字符c, 蒙受NULL甘休符截至.

函数重返内容调节后的string指针.

char *strnset(char *string, int c, size_t count);

将string串起来count个字符设置为字符c, 借使count值大于string串的尺寸,
将用string的尺寸替换count值.

函数重回内容调解后的string指针.

size_t strspn(const char *string, const char *strCharSet);

查找任何多少个不带有在strCharSet串中的字符 (字符串截止符NULL除却)
在string串中第二次现身的岗位序号.

回来二个卡尺头值, 钦命在string中全体由characters中的字符组成的子串的长度.
即使string以叁个不包括在strCharSet中的字符起头, 函数将重返0值.

size_t strcspn(const char *string, const char *strCharSet);

检索strCharSet串中任何一个字符在string串中第叁遍现身的岗位序号,
包涵字符串甘休符NULL.

回到二个大背头值,
内定在string中全体由非characters中的字符组成的子串的长度.
假如string以三个满含在strCharSet中的字符初阶, 函数将重返0值.

char *strspnp(const char *string, const char *strCharSet);

寻找任何叁个不带有在strCharSet串中的字符 (字符串结束符NULL除却)
在string串中第贰回面世的职分指针.

归来多个指针, 指向非strCharSet中的字符在string中第壹遍面世之处.

char *strpbrk(const char *string, const char *strCharSet);

搜索strCharSet串中其余二个字符在string串中第二回面世的职位,
不富含字符串结束符NULL.

归来叁个指针, 指向strCharSet中任一字符在string中第三遍面世的地点.
假如八个字符串参数不含相仿字符, 则重返NULL值.

int strcmp(const char *string1, const char *string2);

正如字符串string1和string2大小.

返回值< 0, 表示string1小于string2;

重返值为0, 表示string1等于string2;

返回值> 0, 表示string1大于string2.

int stricmp(const char *string1, const char *string2);

正如字符串string1和string2大大小小,和strcmp差异,
相比的是它们的小写字母版本.

再次回到值与strcmp相似.

int strcmpi(const char *string1, const char *string2);

等价于stricmp函数, 只是提供一个向后格外的版本.

int strncmp(const char *string1, const char *string2, size_t count);

相比较字符串string1和string2高低,只相比前边count个字符. 相比进程中,
任何一个字符串的长短小于count, 则count将被极短的字符串的长度替代.
这时候豆蔻年华旦两串前边的字符都分外, 则相当的短的串要小.

归来值< 0, 表示string1的子串小于string2的子串;

重返值为0, 表示string1的子串等于string2的子串;

回来值> 0, 表示string1的子串大于string2的子串.

int strnicmp(const char *string1, const char *string2, size_t count);

相比字符串string1和string2尺寸,只比较后边count个字符.
与strncmp分化的是, 相比的是它们的小写字母版本.

再次回到值与strncmp雷同.

char *strtok(char *strToken, const char *strDelimit);

在strToken 串中寻找下二个标识,
strDelimit字符集则内定了在时下搜索调用中可能蒙受的交界符.

再次回到二个指针, 指向在strToken中找到的下叁个标识. 假使找不到标志,
就回来NULL值. 每一趟调用都会订正strToken内容,
用NULL字符替换遇到的每一种分界符.

从那之后,字符串操作大概就介绍完了。

上文还会有二个疑难,正是何许读入举例 I love you
那样断断续续的字符串。这么些难题笔者然后将会去重新学习一下输入输出语句,届时候再和贵宗一块享受。

下边,以一大致的实例介绍本篇博客。

标题陈诉:判定叁个由a~z那二十几个字符组成的字符串中哪些字符现身的次数最多。

输入:第意气风发行是测量试验数据的组数n(n<=10卡塔 尔(阿拉伯语:قطر‎,每组测量检验数据占生龙活虎行,不超越80字符且非空、

输出:意气风发行输出蕴涵出现次数最多的字符和该字符现身的次数,中间是一个空格,假若次数雷同,输出ASCII码最小的字符。

鉴于比较简单,笔者就一贯上代码了。不懂的信赖看了代码也能理解的、

#include “stdio.h”

void main()

{

char str[81];

int count[26], i, k, n;  //30个假名的流速计

scanf(“%d”,&n);   //测验数据组数

while (n–>0)

{

scanf(“%s”,str);   //读入字符串

for (i=0; i<26; i++)   //初阶化字符串,个数清0

{

count[i] = 0;

}

i = 0;

while ( str[i] != ‘\0’)

{

count[str[i] – ‘a’]++;         //对现身的字符计数

i++;

}

k = 0;

for (i=1; i<26; i++)

{

if (count[i] > count[k])

{

k = i;                         //查找次数最多的

}

}

printf(“%c %d\n”, ‘a’+k,count[k]);

}

}

相关文章