C语言学习笔记二（字符串）

 

1、 C对字符串的存储

        实例：定义一个256个字符的字符串，并将字母表中的大写字母存储在前26位

char string[256];
         int i;
         for(i = 0; i <26; i++ )
         {
                   string[i]='A'+i;
         }
         string[i]=NULL;
         printf("The string contains %s/n",string);

2、 计算字符串的长度

         法1：

char string[256];
         int i;
         gets(string);
         for(i = 0; string[i] != NULL;i++)
                   putchar(string[i]);
         printf("该字符串的长度为：%d",i);

         法2：大多数C编译器提供了strlen函数，它返回串的字符数目。

char string[]="something......"
         strlen(string);

         为了更好地理解strlen函数如何工作，可以考虑如下方法，该方法计算字符串的长度但是不返回NULL字符。

size_t strlen(const char string)
          {
                   inti = 0;
                   while(string[i])
                            i++;
                   returni;
          }

3、 将一个字符串复制到另一个字符串中

#include <string.h>
         char *strcpy(char *destination,const char *source);

         为了理解strcpy函数是如何工作的，可以思考如下的方法：

char *strcpy(char *destination, constchar *source)
               {
                 while(*destination++  =  *source++)
                      ;
                 return (destination-1)
               }

4、  将一个字符串追加到另一个字符串上

#include <string.h>
         char *strcat(char *target, const char *source)

         为了更好地理解strcat函数，思考如下的方法：

char *strcat(char *target, const char *source)
         {
            char *original = target;
            while(*target)
            target++;    //find the end ofthe string
            while(*target ++  = *source++)
                   ;
            return(original);
           }

5、  给字符串追加N个字符

#include <string.h>
         char *strncat(char *destination,const char *source,int n);

         为了更好地理解strncat函数，思考如下方法：

char *strncat(char *destination,const char *source,int n)
          {
             char *original = destination;
             int i = 0;
             while(*destination)
                destination++;    //find the end ofthe string
              while((i++ < n)  &&  (*destination++ =  *source++))
                   ;
               if(i  >  n)
                   *destination= NULL;
               return(original);
            }

6、  判断两个字符串是否相同

int streql(char *string1, char *string2)
          {
            while((*string1 == *string2)&& (*string1))
            {
                   string1++;
                   string2++;
            }
          return((*string1 == NULL)&& (string2 == NULL));
          }

7、  比较字符串时忽略大小写

#include <ctype.h>
         int strieql(char *string1, char *string2)
       {
           while((toupper(*string1)== toupper(*string2))&& *string1)
          {
                   string1++;
                   string2++;
          }
          return( (*string1 == NULL)&& (*string2 == NULL) );
        }

8、  将字符串转化为大写或者小写

#include <ctype.h>
int *strlwr(char *string)
{
         char *original = string;
         while(*string)
         {
                   *string= tolower(*string);
                   string++;
         }
         return(original);
}

9、  获取字符串中第一次出现的某个字符

char *strchr(const char *string, char letter)
{
         while((*string != letter)&& (*string))
                   string++;
         return(string);
}

10、返回索引到串的首次出现

int str_index(const char *string, char letter)
{
         char *original = string;
         while((*string != letter)&& (*string))
                   string++;
         return(string - original);
}

11、将字符串的字母反转

char *strrev(const char *string)
{
         char temp;
         char *original = string;
         char *forward = string;
         while(*string)
                   string++;
         while(forward < string)
         {
                   temp= *(--string);
                   *(--string)= *(forward);
                   *(forward++)= temp;
         }
         return original;
}

12、比较两个字符串

int strcmp(const char *string1, const char *string2)
{
         while((*string1 == *string2)&& (*string1) )
         {
                   string1++;
                   string2++;
         }
         if((*string1 == *string2)&& (!*string1))
                   return0;//Same strings
         else if((*string1)&& (!*string2))
                   return(-1); //Same but string1 is longer
         else if((!*string1)&& (*string2))
                   return(1);  //Samebut string2 is longer
         else
                   return( (*string1 > *string2)? -1: 1); //Different
}

13、比较两个字符串的前N个字符串

int strncmp(const char *string1, const char *string2, size_t n)
{
         while((*string1 == *string2)&& (*string1) && i < n)
         {
                   string1++;
                   string2++;
         }
         if(i == n)
                   return0;
         else if((*string1 == *string2) && (!*string1))
                   return0;//Same strings
         else if((*string1)&& (!*string2))
                   return(-1); //Same but string1 is longer
         else if((!*string1)&& (*string2))
                   return(1);  //Samebut string2 is longer
         else
                   return( (*string1 > *string2)? -1: 1); //Different
}

14、将字符串转化为数字

函数	用途
atof	将字符串转换为浮点数值
atoi	将字符串转换为整型数值
atol	将字符串转换为长整数数值
strtod	将字符串转换为双精度型数值
strtol	将字符串转换为长整型数值

 15、复制字符串的内容

调用strdup函数时，函数使用malloc分配内存，然后哦将字符串单元拷贝至内存单元。但程序不再使用字符串拷贝。

#include <string.h>
#include <malloc.h>
char *strdup(const char *string)
{
         char *ptr;
         if(ptr = malloc(strlen(string)+1))
                   strcpy(ptr,string);
         return ptr;
}

16、从给定字符序列中查找字符的首次出现

在字符串string1中，函数将返回第一个不包含在string2中的字符的偏移量。

size_t strspn(const char *string1, const char *string2)
{
         int i, j;
         for(i = 0; *string1;string1++,i++)
         {
                   for(j = 0; string2[j]; j++)
                   {
                            if(*string1 == string2[j])
                                     break;
                            if(string2[j] == NULL)
                                     break;
                   }
         }
         return i;
}

17、在字符串中查找子字符串

char *strstr(const char *string1, const char *string2)
{
         int i,j,k;
         for(i = 0; string1[i];i++)
                   for(j = i, k=0; string1[j] == string2[k]; j++, k++)
                            if(!string2[k+1])
                                     return (string1 + i);
         return NULL;
}

18、计算子字符串出现的次数

char strstr_cnt(const char *string, const char *substring)
{
         int i,j,k,count=0;
         for(i = 0; string[i]; i++)
                   for(j = i, k=0; string[j] == substring[k]; j++, k++)
                            if(!substring[k+1])
                                     count++;
         return count;
}

19、从字符串中删除子字符串

char *strstr_rem(char *string, char *substring)
{
         int i,j,k, loc = -1;
         for(i = 0; string[i] && (loc== -1); i++)
                   for(j = i, k = 0; string[j] == substring[k]; j++, k++)
                            if(! substring[k + 1])
                                     loc = i;
         if(loc != -1)
         {
                   for(k = 0; substring[k]; k++)
                            ;
                            for(j = loc, i = loc + k; string[i]; j++, i++)
                                     string[j] = string[i];
                            string[i] = NULL;
         }
         return(string);
}

20、用另一个子字符串代替子字符串

#include <string.h>
char *strstr_rep(char *Source, char *Old, char *New)
{
         char *original = Source;
         char temp[256];
         int old_length = strlen(Old);
         int i,j,k, location =-1;
         for(i = 0; Source[i]; i++)
                   for(j = i, k = 0; Source[j] == Old[k]; j++,k++ )
                            location++;
         if(location != -1)
         {
                   for(j = 0; j < location; j++)
                            temp[j] = Source[j];
                   for(i = 0; New[i]; i++,j++)
                            temp[j] = New[i];
                   for(k = location + old_length; Source[k]; k++,j++)
                            temp[j] = Source[k];
                   Source[j] = NULL;
                   for(i = 0; Source[i] = temp[i]; i++);
         }
         return original;
}

21、判断字符串是大写还是小写

if(islower(character))
if(isupper(character))

#define islower(c) (((c) > 'a') &&((c)< 'z'))
#define isupper(c) (((c) > 'A') &&((c)< 'Z'))

22、将字符转换成大写形式

#include <ctype.h>

int _toupper(int character);
int toupper(int character);

23、将字符转换成小写形式

#include <ctype.h>

int _tolower(int character);
int tolower(int character);

24、初始化字符串

char title[] = "something......."
char str[64] = "string..."