#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) ;
}

#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*/
}

#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．  */
}

#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. * /
}

# 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]) ;
    }
}

    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

# include <stdio. h>
# include <string. h>

void main(void);
void main (void)
{
    char * source_str = "THIS IS THE SOURCE STRING" ;
    char dest_strl[40]= {0}, dest_str2[40]= {0};
    / * Use strncpy() to copy only the first 11 characters. * /
    strncpy(dest_strl, source-str, 11);
    printf("How about that! dest-strl is now: '%s'!!!\n", dest-strl);
    / * Now, use strncpy() to copy only the last 13 characters. * /
    strncpy(dest_strl, source_str + (strlen(source_str)-l3) , 13);
    printf("Whoa! dest_str2 is now: '%s'!!!\n". dest_str2);
}

# include <stdio. h>
# include <stdlib. h>

void main (void);
void main (void)
{
    int num = 100;
    char str[25];
    itoa(num, str, 10);
    printf("The number 'num' is %d and the string 'str' is %s. \n" ,
                       num, str);
}

  
#include<stdio.h>  
# include <stdlib. h>

void main (void);
void main (void)
{
    int num = 100;
    char str[25];
    sprintf(str, " %d" , num);
   printf ("The number 'num' is %d and the string 'str' is %s. \n" ,
                          num, str);

}

# include <stdio. h>
# include <stdlib. h>

void main (void);
void main (void)
{
    double num = 12345.678;
    char * sir;
    int dec_pl, sign, ndigits = 3; /* Keep 3 digits of precision. * /
    str = fcvt(num, ndigits, &dec-pl, &sign); /* Convert the float
                                                 to a string. * /
    printf("Original number; %f\n" , num) ;  /* Print the original
                                                 floating-point
                                                    value. * /
    printf ("Converted string; %s\n",str);    /* Print the converted
                                                string's value. * /
    printf ("Decimal place: %d\n" , dec-pi) ; /* Print the location of
                                                 the decimal point. * /
    printf ("Sign: %d\n" , sign) ;            /* Print the sign.
                                                 0 = positive,
                                                 1 = negative. * /
}

# include <stdio. h>
# include <stdlib. h>

void main (void) ;
void main (void)
{
    int num;
    char * str = "100";
    num = atoi(str);
    printf("The string 'str' is %s and the number 'num' is %d. \n",
                   str, num);
}

 
# include <stdio. h>
# include <stdlib. h>
# include <limits. h>

void main(void);
void main (void)
{
    char* str = "1234567891011121314151617181920" ;
    unsigned long num;
    char * leftover;
    num = strtoul(str, &leftover, 10);
    printf("Original string: %s\n",str);
    printf("Converted number: %1u\n" , num);
    printf("Leftover characters: %s\n" , leftover);
}

# include <stdio. h>
# include <stdlib. h>

void main (void);
void main (void)
{
    char * source_str = "THIS IS THE SOURCE STRING" ;
    / * Use printfO to print the first 11 characters of source_str. * /
    printf("First 11 characters: ' %11. lls'\n" , source_str);
    / * Use printf() to print only the
        last 13 characters of source _str. * /
    printf("Last 13 characters:'%13.13'\n",
                    source_str+(strlen(source_str)-13))；
}

#include <stdio. h>
#include <string. h>

void main (void);
void main(void)
{
    char* str_1 = "abc" ; char * str_2 = "abc" ; char* str_3 = "ABC" ;
    if (strcmp(str_1, str_2) == 0)
        printf("str_1 is equal to str_2. \n");
    else
        printf("str_1 is not equal to str_2. \n");
    if (strcmp(str_1, str_3) == 0)
       printf("str_1 is equal to str_3．\n");
    else
        printf("str_1 is not equalto str_3．\n")；
}