Strings - C Interview Questions and Answers

Why "C Programming - Strings" Interview Questions?

In this section you can learn and practice interview questions based on ""C Programming - Strings"" and improve your skills in order to face the interview, competitive examination and various entrance tests (CAT, GATE, GRE, MAT, Bank Exam, Railway Exam etc.) with full confidence.

Where can I get "C Programming - Strings" interview questions and answers with explanation?

IndiaBIX provides you lots of fully solved "C Programming - Strings" interview questions and answers with Explanation. All students, freshers can download "C Programming - Strings" quiz questions with answers as PDF files and eBooks. Solved examples with detailed answer description, explanation are given and it would be easy to understand. View the solution for the problems with feel and good user interface; easily go through all questions and answers.

How to answer "C Programming - Strings" interview questions?

You can easily answer the interview questions based on "C Programming - Strings" by practicing the exercises given below.


  1. What is the difference between a string copy (strcpy) and a memory copy (memcpy)? When should each be used?

    The strcpy() function is designed to work exclusively with strings. It copies each byte of the source string to the destination string and stops when the terminating null character (\0) has been moved. On the other hand, the memcpy() function is designed to work with any type of data.

    Because not all data ends with a null character, you must provide the memcpy() function with the number of bytes you want to copy from the source to the destination. The following program shows examples of both the strcpy() and the memcpy() functions:

    #include <stdio.h>
    #include <string.h>
    typedef struct cust_str {
         int  id;
         char last_name[20];
         char first_name[15];
    } 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");
         printf("I'll copy src_cust into dest_cust.\n");
         /* First, initialize 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);
    }
    

    When dealing with strings, you generally should use the strcpy() function, because it is easier to use with strings. When dealing with abstract data other than strings (such as structures), you should use the memcpy() function.

  2. How can I remove the trailing spaces from a string?

    The C language does not provide a standard function that removes trailing spaces from a string. It is easy, however, to build your own function to do just this. The following program uses a custom function named rtrim() to remove the trailing spaces from a string. It carries out this action by iterating through the string backward, starting at the character before the terminating null character (\0) and ending when it finds the first nonspace character. When the program finds a nonspace character, it sets the next character in the string to the terminating null character (\0), thereby effectively eliminating all the trailing blanks. Here is how this task is performed:

    #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'\n", trail_str);
         printf("and has a length of %d.\n", strlen(trail_str));
         /* Call the rtrim() function to remove the trailing blanks. */
         rtrim(trail_str);
         /* Show the status of the string
            after calling the rtrim() function. */
         printf("After calling rtrim(), 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 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. */
    }
    

    Notice that the rtrim() function works because in C, strings are terminated by the null character. With the insertion of a null character after the last nonspace character, the string is considered terminated at that point, and all characters beyond the null character are ignored.