第6章 字符串操作.txt

我自己整理的c语言教程 来自 c语言之家

C语言编程常见问题解答  
 

 
发表日期：2003年9月30日      已经有2342位读者读过此文 
 


                                     第6章  字符串操作

    本章集中讨论字符串操作，包括拷贝字符串，拷贝字符串的一部分，比较字符串，字符串右对齐，删去字符串前后的空格，转换字符串，等等。C语言提供了许多用来处理字符串的标准库函数，本章将介绍其中的一部分函数。
    在编写C程序时，经常要用到处理字符串的技巧，本章提供的例子将帮助你快速学会一些常用函数的使用方法，其中的许多例子还能有效地帮助你节省编写程序的时间。

    6．1 串拷贝(strcpy)和内存拷贝(memcpy)有什么不同?它们适合于在哪种情况下使用?
    strcpy()函数只能拷贝字符串。strcpy()函数将源字符串的每个字节拷贝到目录字符串中，当遇到字符串末尾的null字符(\0)时，它会删去该字符，并结束拷贝。
    memcpy()函数可以拷贝任意类型的数据。因为并不是所有的数据都以null字符结束，所以你要为memcpy()函数指定要拷贝的字节数。
      在拷贝字符串时，通常都使用strcpy()函数；在拷贝其它数据(例如结构)时，通常都使用memcpy()函数。
    以下是一个使用strcpy()函数和memcpy()函数的例子：

#include <stdio. h>
#include <string. h>
typedef struct cust-str {
    int id ;
    char last_name [20] ;
    char first_name[l5];
} CUSTREC;
void main (void);
void main (void)
{
    char * src_string = "This is the source string" ;
    char dest_string[50];
    CUSTREC src_cust;
    CUSTREC dest_cust;
    printf("Hello! I'm going to copy src_string into dest_string!\n");
    / * Copy src_ string into dest-string. Notice that the destination
      string is the first argument. Notice also that the strcpy()
      function returns a pointer to the destination string. * /
    printf("Done! dest_string is: %s\n" ,
        strcpy(dest_string, src_string)) ;
    printf("Encore! Let's copy one CUSTREC to another. \n") ;
    prinft("I'll copy src_cust into dest_cust. \n");
    / * First, intialize the src_cust data members. * /
    src_cust. id = 1 ;
    strcpy(src_cust. last_name, "Strahan");
    strcpy(src_cust. first_name, "Troy");
    / * Now, Use the memcpy() function to copy the src-cust structure to
        the dest_cust structure. Notice that, just as with strcpy(), the
        destination comes first. * /
    memcpy(&dest_cust, &src_cust, sizeof(CUSTREC));
    printf("Done! I just copied customer number # %d (%s %s). " ,
        dest_cust. id, dest_cust. first_name, dest_cust. last_name) ;
}

    请参见：    
    6．6怎样拷贝字符串的一部分?
    6．7怎样打印字符串的一部分?

    6. 2怎样删去字符串尾部的空格?。
    C语言没有提供可删去字符串尾部空格的标准库函数，但是，编写这样的一个函数是很方便的。请看下例：
#include <stdio. h>
# include <string. h>

void main (void);
char * rtrim(char * );
void main(void)
{
    char * trail_str = "This string has trailing spaces in it";
   / * Show the status of the string before calling the rtrim()
       function. * /
    printf("Before calling rtrim(), trail_str is '%s'\fi" , trail_str);
    print ("and has a length of %d. \n" , strlen (trail_str));
   / * Call the rtrimO function to remove the trailing blanks. * /
    rtrim(trail_str) ;
   / * Show the status of the string
       after calling the rtrim() function. * /
    printf("After calling rttim(), trail_ str is '%s'\n", trail _ str );
    printf ("and has a length of %d. \n" , strlen(trail-str)) ;
}
/ * The rtrim() function removes trailing spaces from a string. * /.

char * rtrim(char * str)
{
    int n = strlen(str)-1; / * Start at the character BEFORE
                               the null character (\0). * / 
    while (n>0) / * Make sure we don't go out of hounds. . . * /
    {
        if ( * (str + n) 1 =' ') / * If we find a nonspace character: * /
        {
            * (str+n+1) = '\0' ; / * Put the null character at one
                                     character past our current
                                     position. * /
            break ; / * Break out of the loop. * /
        }
        else / * Otherwise , keep moving backward in the string. * /.
            n--;
    }
    return str;    /*Return a pointer to the string*/
}

    在上例中，rtrim()是用户编写的一个函数，它可以删去字符串尾部的空格。函数rtrim()从字符串中位于null字符前的那个字符开始往回检查每个字符，当遇到第一个不是空格的字符时，就将该字符后面的字符替换为null字符。因为在C语言中null字符是字符串的结束标志，所以函数rtrim()的作用实际上就是删去字符串尾部的所有空格。

    请参见：    
    6．3怎样删去字符串头部的空格?
    6．5怎样将字符串打印成指定长度?
    
    6．3  怎样删去字符串头部的空格?
    C语言没有提供可删去字符串头部空格的标准库函数，但是，编写这样的一个函数是很方便的。请看下例；
#include <stdio. h> 
#include <string. h>

void main(void); 
char *  ltrim (char * ) ; 
char * rtrim(char * ) ;
void main (void)
{
    char * lead_str = " This string has leading spaces in it. " ;,
    / * Show the status of the string before calling the Itrim()
        function. * /
    printf("Before calling Itrim(), lead-str is '%s'\n", lead_str);
    printf("and has a length of %d. \n" , strlen(lead_str));
    / * Call the Itrim() function to remove the leading blanks. * /.
        Itrim(lead_str);
    / * Show the status of the string
        after calling the Itrim() function. * /
    prinft("After calling Itrim(), lead_str is '%s'\n", lead_str);
    print("and has a length of %d. \n'' , strlen(lead-str)) ;
}
/ * The Itrim() function removes leading spaces from a string. * /

char * ltrim(char * str)
{
    strrev(str) ; / * Call strrevO to reverse the string. * /
    rtrim(str)). /* Call rtrimO to remvoe the "trailing" spaces. * /
    strrev(str); / * Restore the string's original order. * /
    return str ; / * Return a pointer to the string. * /.
}
/ * The rtrim() function removes trailing spaces from a string. * /

char* rtrim(char* str)
{
    int n = strlen (str)-l ; / * Start at the character BEFORE
    the null character (\0). * /
    while (n>0) / * Make sure we don't go out of bounds... * /.
    {
        if ( * (str+n) ! =' ') If we find a nonspace character: * /
        {
            * (str+n + 1) = '\0' ; / * Put the null character at one
            character past our current
            position. * /
            break;j / * Break out of the loop. * /
        }
        else / * Otherwise, keep moving backward in the string. * /
            n --;
    }
    return  str；    /*  Return a pointer tO the string．  */
}

    在上例中，删去字符串头部空格的工作是由用户编写的ltrim()函数完成的，该函数调用了·6．2的例子中的rtrim()函数和标准C库函数strrev()。ltrim()函数首先调用strrev()函数将字符串颠倒一次，然后调用rtrim()函数删去字符串尾部的空格，最后调用strrev()函数将字符串再颠倒一次，其结果实际上就是删去原字符串头部的空格。

    请参见：
    6．2怎样删去字符串尾部的空格?    
    6．5怎样将字符串打印成指定长度?  

    6．4  怎样使字符串右对齐?    
    C语言没有提供可使字符串右对齐的标准库函数，但是，编写这样的一个函数是很方便的。请看下例：
#include <stdio. h>
#include <string. h>
#include <malloc. h>

void main (void);
char * r just (char * ) ;
char * rtrim(char * );
void main (void)
{
    char * rjust_str = "This string is not righ-justified. " ;
    / * Show the status of the string before calling the rjust()
        function. * /
    printf("Before calling rjust(), rjust_str is ' %s'\n. " , rjust_str);
    / * Call the rjustO function to right-justify this string. * /
    rjust(rjust_str) ;
    / * Show the status of the string
        after calling the rjust() function. * /
    printf ("After calling rjust() , rjust_str is ' %s'\n. " , rjust_str) ;
}
/ * The rjust() function right-justifies a string. * /
char * r just (char * str)
{
    int n = strlen(str); / * Save the original length of the string. * /
    char* dup_str;
    dup_str = strdup(str); / * Make an exact duplicate of the string. * /
    rtrim(dup_str); /* Trim off the trailing spaces. */
    / * Call sprintf () to do a virtual "printf" back into the original
        string. By passing sprintf () the length of the original string,
        we force the output to be the same size as the original, and by
        default the sprintf() right-justifies the output. The sprintf()
        function fills the beginning of the string with spaces to make
        it the same size as the original string. * /

    sprintf(str, "%*. * s", n, n, dup_str);

    free(dup-str) ; / * Free the memory taken by
    the duplicated string. * /
    return str;\ / * Return a pointer to the string. * /
}

/ * The rtrim() function removes trailing spaces from a string. * /
char * rtrim(char * str)
{
    int n = strlen(str)-l; / * Start at the character BEFORE the null
                               character (\0). * /
    while (n>0) / * Make sure we don't go out of bounds... * /
    {
        if ( * (str+n) ! = ' ') / * If we find a nonspace character: * /
        {
            * (str + n + 1) = '\0';( / * Put the null character at one
                                         character past our current
                                         position. * /
             break; / * Break out of the loop. * /
        }
        else / * Otherwise, keep moving backward in the string. * /
            n—;
    }
    return str ; / * Return a pointer to the string. * /
}
  
   在上例中，使字符串右对齐的工作是由用户编写的rjust()函数完成的，该函数调用了6．2的例子中的rtrim()函数和几个标准函数。rjust()函数的工作过程如下所示：
    (1) 将原字符串的长度存到变量n中。这一步是不可缺少的，因为输出字符串和原字符串的长度必须相同。
    (2) 调用标准C库函数strdup()，将原字符串复制到dup_str中。原字符串需要有一份拷贝，因为经过右对齐处理的字符串要写到原字符串中。
    (3) 调用rtrim()函数，删去dup_str尾部的空格。
    (4) 调用标准C库函数sprinf()，将dup_str写到原字符串中。由于原字符串的长度(存在n中)被传递给sprintf()函数，所以迫使输出字符串的长度和原字符串相同。因为sprintf()函数缺省使输出字符串右对齐，因此输出字符串的头部将被加入空格，以使它和原字符串长度相同，其效果实际上就是使原字符串右对齐。
    (5)调用标准库函数free()，释放由strdup()函数分配给dup_str的动态内存。

    请参见：    
    6．5怎样将字符串打印成指定长度?    

    6．5  怎样将字符串打印成指定长度?    
    如果要按表格形式打印一组字符串，你就需要将字符串打印成指定长度。利用printf()函数可以很方便地实现这一点，请看下例:

# include <stdio. h>
char * data[25] = {
    "REGION", "--Q1--", "--Q2--", "--Q3--", "--Q4--",
    "North" , "10090. 50" , "12200. 10" , "26653.12" , "62634. 32" ,
    "South", "21662.37", "95843.23", "23788.23", "48279.28",
    "East", "23889.38", "23789.05", "89432.84", "29874.48",
    "West", "85933.82", "74373.23", "78457.23", "28799.84" };
void main (void) ;
void main (void)
{
    int x;
    fox (x = 0, x<25; x+ + )
    {
        if ((x % 5) == 0&&(x !=0))
        printf("\n");
        printf (" %-10. 10s" , data[x]) ;
    }
}
  
    在上例中，字符串数组char *data[]中包含了某年4个地区的销售数据。显然，你会要求按表格形式打印这些数据，而不是一个挨一个地毫无格式地打印这些数据。因此，上例中用下述语句来打印这些数据：
    printf("%-10．10s"，data[x])；
    参数"%-10．10s"指示printf()函数按10个字符的长度打印一个字符串。在缺省情况下，printf()函数按右对齐格式打印字符串，但是，在第一个10的前面加上减号(-)后，prinft()函数，就会使字符串左对齐。为此，printf()函数会在字符串的尾部加入空格，以使其长度达到10个字符。上例的打印输出非常整洁，类似于一张表格，如下所示：

    REGION    --Q1--    --Q2--     --Q3--     --Q4--