char[] 操作

字符串的初始化方法
1、char str[10] = { 'H', 'e', 'l', 'l', 'o', '\0' };
2、char str[10] = "Hello";
   char str[] = "linguoyuan\n";

字符串处理在程序中很常见，C库也提供了很多字符串的处理函数，它们有一个共同特点就是都要包含头文件string.h。
1、计算字符串长度：strlen、sizeof
头文件：string.h
格式：strlen (字符数组名)
功能：计算字符串s的(unsigned int型)长度,不包括'\0'在内
说明：返回s的长度，不包括结束符'\0'。


与此有点类似有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\n";
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并不是遇到'\0'就结束，而是一定会拷贝完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值大小相比较），直到出现不同的字符或遇'\0'为止。
以下是一个实现strcmp的例子：
#include<stdio.h>
int mystrcpy(char s1[],char s2[])
{
    int i;
    for(i=0;s1[i]==s2[i];i++)
        if(s1[i]=='\0')
            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\n",i);
    return 0;
}

（2）memcmp从前到后逐个比较缓冲区s1和s2的前n个字节（不管里面有没有'\0'），如果s1和s2的前n个字节全都一样就返回0，如果遇到不一样的字节，s1的字节比s2小就返回负值，s1的字节比s2大就返回正值。

（3）strncmp与strcmp的唯一区别是即使两个字符串还没遇到'\0',比较到了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\n", d, s);

调用strcat函数后，缓冲区s的内容没变，缓冲区d中保存着字符串"foobar"，注意原来"foo"后面的'\0'被连接上来的字符串"bar"覆盖掉了，"bar"后面的'\0'仍保留。

strcat和strcpy有同样的问题，调用者必须确保dest缓冲区足够大，否则会导致缓冲区溢出错误。strncat函数通过参数n指定一个长度，就可以避免缓冲区溢出错误。注意这个参数n的含义和strncpy的参数n不同，它并不是缓冲区dest的长度，而是表示最多从src缓冲区中取n个字符（不包括结尾的'\0'）连接到dest后面。如果src中前n个字符没有出现'\0'，则取前n个字符再加一个'\0'连接到dest后面，所以strncat总是保证dest缓冲区以'\0'结尾，这一点又和strncpy不同，strncpy并不保证dest缓冲区以'\0'结尾。所以，提供给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\n",b);
    while( (c = strtok(NULL," "))  != NULL )
    {  
        b = atoi(c);
        printf("%d\n",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\n",s);  
10 }
11 int main(int argc,char*argv[])
12 {   
13 char ch='b';
14  char str[]="abc";
15
16  printf("%s\n",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!='\n')
13         {
14                 buf[i]=a;
15                 a=getchar();
16                 i++;
17         }
18         buf[i]='\0';
19         printf("shuru:%s\n",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\n",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]='\0';
13  printf("while:%s\n",s2);

14  for(i=0;i<strlen(s1);i++)
15      s2[i]=s1[i];
16  printf("for:%s\n",s2);

17  strcpy(s2,s1);
18  printf("strcpy:%s\n",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!\n");
11        return NULL;
12    }
13    while(count&&(*tmp = *src))
14    {
15        tmp++;
16        src++;
17        count--;
18    }
19    printf("count=%d\n",count);
20    if(count)
21        while(count)
22        {
23            printf("in while,count=%d\n",count);
24            *tmp++ = '\0';
25            count--;
26        }
27    return dest;
28  }
29
30  int main(int argc,char*argv[])
31  {
32    char dest[N] = {'\0'};
33    char src[15] = "Hello!";
34    if(argc!=2)
35    {
36        printf("You need input a number!\n");
37        return 0;
38    }
39    printf("After my_strncpy,dest=%s\n",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\n",a);
16    else
17      printf("Has not character'e'need to converse!\n");
18    return 0;
19 }