字符串的初始化方法
1、char str[10] = { 'H', 'e', 'l', 'l', 'o', ' ' };
2、char str[10] = "Hello";
char str[] = "linguoyuan
";
字符串处理在程序中很常见，C库也提供了很多字符串的处理函数，它们有一个共同特点就是都要包含头文件string.h。
1、计算字符串长度：strlen、sizeof
头文件：string.h
格式：strlen (字符数组名)
功能：计算字符串s的(unsigned int型)长度,不包括' '在内
说明：返回s的长度，不包括结束符' '。
与此有点类似有sizeof，但它和strlen函数不一样，它只是一个操作符，而且sizeof（）返回的是所声明的变量的内存大小，eg：char str[10] = "lin"; strlen(str)返回3，而sizeof(str)返回的是10。
上面是对静态数组处理的结果，如果是对指针，结果就不一样了
char* ss = "0123456789";
sizeof(ss) 结果 4 ===》ss是指向字符串常量的字符指针，sizeof 获得的是一个指针的之所占的空间,应该是
长整型的，所以是4
sizeof(*ss) 结果 1 ===》*ss是第一个字符其实就是获得了字符串的第一位'0' 所占的内存空间，是char类型的，占了 1 位
strlen(ss)= 10 >>>> 如果要获得这个字符串的长度，则一定要使用 strlen
sizeof返回对象所占用的字节大小.
strlen返回字符个数.
所以注意下面的情况：
（1）
char Array[3] = {'0'};
sizeof(Array) == 3;
char *p = Array;
sizeof(p) == 1;//sizeof(p)结果为4
在传递一个数组名到一个函数中时，它会完全退化为一个指针
（2）
char q[]="abc";
char p[]="a
";
sizeof(q),sizeof(p),strlen(q),strlen(p);
结果是 4 3 3 2
2、复制字符串函数：strcpy、strncpy、memcpy、memmove
（1）原型：char *strcpy(char *dest,char *src);
头文件：string.h
功能：把从src地址开始且含有NULL结束符的字符串赋值到以dest开始的地址空间
说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
返回指向dest的指针。
（2）strncpy与strcpy的不同之处就是带一个参数指定最多拷贝多少个字节。
（3）
void *memcpy(void *dest, const void *src, size_t n);
memcpy函数从src所指的内存地址拷贝n个字节到dest所指的内存地址，和strncpy不同，memcpy并不是遇到' '就结束，而是一定会拷贝完n个字节。注意：src和dest所指内存区域不能重叠，函数返回指向destin的指针
void *memmove(void *dest, const void *src, size_t n);
memmove也是从src所指的内存地址拷贝n个字节到dest所指的内存地址，虽然叫move但其实也是拷贝而非移动。但是和memcpy有一点不同，memcpy的两个参数src和dest所指的内存区间如果重叠则无法保证正确拷贝，而memmove却可以正确拷贝。
3、比较字符串：strcmp、memcmp、strncmp
（1）strcmp
功能：比较字符串s1和s2。
原型：strcmp(const char *s1,const char * s2)
当s1<s2时，返回值<0
当s1=s2时，返回值=0
当s1>s2时，返回值>0
两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇' '为止。
以下是一个实现strcmp的例子：
#include<stdio.h>
int mystrcpy(char s1[],char s2[])
{
int i;
for(i=0;s1[i]==s2[i];i++)
if(s1[i]==' ')
return 0;
if(s1[i]-s2[i]>0)
return 1;
else
return -1;
}
int main(int argc,char*argv[])
{
char s1[]="linguoyuan";
char s2[]="xingwenpeng";
int i=mystrcpy(s1,s2);
printf("%d
",i);
return 0;
}
（2）memcmp从前到后逐个比较缓冲区s1和s2的前n个字节（不管里面有没有' '），如果s1和s2的前n个字节全都一样就返回0，如果遇到不一样的字节，s1的字节比s2小就返回负值，s1的字节比s2大就返回正值。
（3）strncmp与strcmp的唯一区别是即使两个字符串还没遇到' ',比较到了n个字符，也已样返回。
4、连接字符串：strcat、strncat
原型：
char *strcat(char *dest, const char *src);
char *strncat(char *dest, const char *src, size_t n);
返回值：dest指向哪，返回的指针就指向哪
strcat把src所指的字符串连接到dest所指的字符串后面
char d[10] = "foo";
char s[10] = "bar";
strcat(d, s);
printf("%s %s
", d, s);
调用strcat函数后，缓冲区s的内容没变，缓冲区d中保存着字符串"foobar"，注意原来"foo"后面的' '被连接上来的字符串"bar"覆盖掉了，"bar"后面的' '仍保留。
strcat和strcpy有同样的问题，调用者必须确保dest缓冲区足够大，否则会导致缓冲区溢出错误。strncat函数通过参数n指定一个长度，就可以避免缓冲区溢出错误。注意这个参数n的含义和strncpy的参数n不同，它并不是缓冲区dest的长度，而是表示最多从src缓冲区中取n个字符（不包括结尾的' '）连接到dest后面。如果src中前n个字符没有出现' '，则取前n个字符再加一个' '连接到dest后面，所以strncat总是保证dest缓冲区以' '结尾，这一点又和strncpy不同，strncpy并不保证dest缓冲区以' '结尾。所以，提供给strncat函数的dest缓冲区的大小至少应该是strlen(dest)+n+1个字节，才能保证不溢出。（这是宋老师书的例子）。
5、搜索字符或字符串：strchr、strrchr
原型：
char *strchr(const char *s, int c);
char *strrchr(const char *s, int c);
返回值：如果找到字符c，返回字符串s中指向字符c的指针，如果找不到就返回NULL
strchr在字符串s中从前到后查找字符c，找到字符c第一次出现的位置时就返回，返回值指向这个位置，如果找不到字符c就返回NULL。strrchr和strchr类似，但是从右向左找字符c，找到字符c第一次出现的位置就返回
char *strstr(const char *haystack, const char *needle);
返回值：如果找到子串，返回值指向子串的开头，如果找不到就返回NULL
strstr在一个长字符串中从前到后找一个子串（Substring），找到子串第一次出现的位置就返回，返回值指向子串的开头，如果找不到就返回NULL。
6、分割字符串：strtok
char *strtok(char *str, const char *delim);
参数str是待分割的字符串，delim是分隔符
以下是一个使用strtok来一个字符串分割成整数：
#include <stdio.h>
#include <string.h>
void main(void)
{
char a[1024];
int b;
char* c;
fgets(a,sizeof(a),stdin);
b = atoi(strtok(a," "));
printf("%d
",b);
while( (c = strtok(NULL," ")) != NULL )
{
b = atoi(c);
printf("%d
",b);
}
}
注意：
strtok函数中有一个静态指针变量记住上次处理到字符串中的什么位置，所以不需要每次调用时都把字符串中的当前处理位置传给strtok。
下面是一些平时练习字符串的例子。
////////删除字符串里的某一个字符///////////
1 #include<stdio.h>
2 void delet_char(char*str,char ch)
3 {
4 int i,j;
5 char s[3];
6 for(i=j=0;str[i];i++)
7 if(str[i]!=ch)
8 s[j++]=str[i];
9 printf("%s
",s);
10 }
11 int main(int argc,char*argv[])
12 {
13 char ch='b';
14 char str[]="abc";
15
16 printf("%s
",str);
17 delet_char(str,ch);
18
19 return 0;
20 }
//////////////////////////////////////////
1
2 #include<stdio.h>
3 int main(int argc,char*argv[])
4 {
5 char a,b;
6 int i=0;
7 int j;
8
9 a=getchar();
10 char buf[10];
11
12 while(a!='
')
13 {
14 buf[i]=a;
15 a=getchar();
16 i++;
17 }
18 buf[i]=' ';
19 printf("shuru:%s
",buf);
20
21 for(j=i-1,i=0;i<j;j--,i++)
22 {
23 b=buf[j];
24 buf[j]=buf[i];
25 buf[i]=b;
26 }
27 printf("shuchu:%s
",buf);
28 }
//////////三种方法实现字符串复制////////////
1 #include<stdio.h>
2 #include<string.h>
3
4 int main(int argc,char*argv[])
5 {
6 char s1[]="Hello World!";
7 char s2[20];
8 int i=0;
9
10 while(s1[i])
11 s2[i++]=s1[i];
12 s2[i]=' ';
13 printf("while:%s
",s2);
14 for(i=0;i<strlen(s1);i++)
15 s2[i]=s1[i];
16 printf("for:%s
",s2);
17 strcpy(s2,s1);
18 printf("strcpy:%s
",s2);
19 return 0;
20 }
/////////////////mystrncpy/////////////
1 #include<stdio.h>
2 #include<string.h>
3 #include<stdlib.h>
4 #define N 20
5 char*my_strncpy(char dest[],char src[],int count)
6 {
7 char*tmp = dest; //注意传进来的是地址
8 if(count<=0||N<count)
9 {
10 printf("Usage count or Space not enough!
");
11 return NULL;
12 }
13 while(count&&(*tmp = *src))
14 {
15 tmp++;
16 src++;
17 count--;
18 }
19 printf("count=%d
",count);
20 if(count)
21 while(count)
22 {
23 printf("in while,count=%d
",count);
24 *tmp++ = ' ';
25 count--;
26 }
27 return dest;
28 }
29
30 int main(int argc,char*argv[])
31 {
32 char dest[N] = {' '};
33 char src[15] = "Hello!";
34 if(argc!=2)
35 {
36 printf("You need input a number!
");
37 return 0;
38 }
39 printf("After my_strncpy,dest=%s
",my_strncpy(dest,src,atoi(argv[1])));
40 return 0;
41 }
////////////////将字符串中的某个字母转化为大写字母//////
1 #include<stdio.h>
2 #define N 20
3 int main(int argc,char*argv[])
4 {
5 char a[N]="I like this game";
6 int num=0;
7 int i;
8 for(i=0;i<N;i++)
9 if(a[i]>='a'&&a[i]<='z'&&a[i]=='g')
10 {
11 a[i]='g'-32;
12 num++;
13 }
14 if(num)
15 printf("After converse,the new string:%s
",a);
16 else
17 printf("Has not character'e'need to converse!
");
18 return 0;
19 }