This is the final lecture of the Strings chapter in the free C programming course. First you build a small command matcher, the kind of code that sits behind a serial console on a real device. Then you test yourself with a quiz, and finish with a set of C strings interview questions and answers that employers use to separate people who memorised syntax from people who understand memory. If you have followed this free embedded C course from the start, you already know everything you need.

Lab: Build a Serial Command Matcher

Many embedded devices accept short text commands over a UART: LED ON, LED OFF, STATUS. Users type them in any letter case, so the firmware normalises the text, looks it up in a table and acts on the result. The program below does exactly that, using only ideas from this chapter.

Save it as cmd_lab.c:

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

static const char *const cmd_table[] = {"LED ON", "LED OFF", "STATUS"};
#define CMD_COUNT (sizeof cmd_table / sizeof cmd_table[0])

static void to_upper(char *s)
{
    for (; *s != '\0'; s++)
        if (*s >= 'a' && *s <= 'z')
            *s = (char)(*s - 'a' + 'A');
}

static int find_command(const char *text)
{
    for (size_t i = 0; i < CMD_COUNT; i++)
        if (strcmp(text, cmd_table[i]) == 0)
            return (int)i;
    return -1;
}

int main(void)
{
    const char *inputs[] = {"led on", "Status", "reboot"};

    for (size_t i = 0; i < sizeof inputs / sizeof inputs[0]; i++) {
        char buf[16];                                  /* writable copy */
        snprintf(buf, sizeof buf, "%s", inputs[i]);
        to_upper(buf);

        int id = find_command(buf);
        if (id >= 0)
            printf("\"%s\" -> %s -> command %d\n", inputs[i], buf, id);
        else
            printf("\"%s\" -> %s -> unknown\n", inputs[i], buf);
    }
    return 0;
}

gcc -std=c17 -Wall -Wextra -o cmd_lab cmd_lab.c
./cmd_lab

Expected output:

"led on" -> LED ON -> command 0
"Status" -> STATUS -> command 2
"reboot" -> REBOOT -> unknown

Why the program is built this way

• cmd_table is an array of pointers to literals, declared const twice so neither the pointers nor the text can change. The table lives in flash.
• The inputs are literals, which cannot be edited, so each one is copied into the writable array buf with snprintf. This is the pattern from Lecture 3 and Lecture 4 together.
• to_upper walks the string with a pointer until the terminator, exactly as in Lecture 5, and changes only lowercase letters.
• find_command uses strcmp, never ==, because content, not address, matters (Lecture 2).
• CMD_COUNT divides the size of the table by the size of one element, so adding a command needs no other edit.

Chapter 9 Recap: What You Learned in C Strings

C Strings Quiz: Multiple Choice

Pick an answer first, then open the box to check it.

1. Which byte ends a C string?

   • A. '0'
   • B. '\0'
   • C. NULL
   • D. EOF
   Show answer

   Answer: B. The terminator is the character with value 0, written '\0'. '0' is the digit with value 48, and NULL is a pointer constant.

2. What does sizeof("UART") evaluate to?

   • A. 4
   • B. 5
   • C. 8
   • D. It depends on the pointer size
   Show answer

   Answer: B. A literal is an array of five chars: four letters and the terminator. sizeof on the literal itself does not use the pointer size.

3. Which declaration lets you safely change the text later?

   • A. char *p = "hi";
   • B. const char *p = "hi";
   • C. char a[] = "hi";
   • D. char *p = &"hi";
   Show answer

   Answer: C. Only the array form gives you a private, writable copy. A and B point at the literal, which is read-only.

4. How do you test whether two strings hold the same characters?

   • A. a == b
   • B. a = b
   • C. strcmp(a, b) == 0
   • D. sizeof(a) == sizeof(b)
   Show answer

   Answer: C. == compares addresses, = is not allowed for arrays, and sizeof compares capacities, not contents.

5. What is the smallest array that can hold a string of up to 11 characters?

   • A. 10 bytes
   • B. 11 bytes
   • C. 12 bytes
   • D. 13 bytes
   Show answer

   Answer: C. Eleven characters plus the terminator need 12 bytes.

6. With scanf("%s", name), what happens if the user types Anil Reddy?

   • A. name holds both words
   • B. name holds Anil and the rest stays in the input
   • C. name holds Reddy
   • D. The program always crashes
   Show answer

   Answer: B. %s stops at whitespace. The remaining text waits in the input buffer for the next read.

7. Which statement about "b" is true?

   • A. It is the integer 98
   • B. It is an array of two chars
   • C. It is a pointer variable
   • D. It is the same as 'b'
   Show answer

   Answer: B. The literal holds the letter and a terminator. The integer 98 is 'b'.

8. Which function was removed from the C standard in C11 because it cannot limit input?

   • A. gets
   • B. fgets
   • C. snprintf
   • D. strlen
   Show answer

   Answer: A. gets has no size argument, so it can never be used safely.

C Strings Quiz: Predict the Output

Each snippet sits inside a main function with stdio.h and string.h included. The answers were produced by compiling and running the code with gcc.

1. char s[] = "ABC";
   printf("%zu %zu\n", sizeof s, strlen(s));

   Show answer

   Output: 4 3

   sizeof counts the terminator, strlen does not.

2. char s[10] = "ab";
   printf("%zu %zu\n", sizeof s, strlen(s));

   Show answer

   Output: 10 2

   The array has capacity 10, but the text is two characters long.

3. printf("%c\n", "firmware"[3]);

   Show answer

   Output: m

   Index 3 of f-i-r-m-w-a-r-e, counting from 0, is m.

4. printf("%zu %zu\n", sizeof("a"), sizeof('a'));

   Show answer

   Output: 2 4

   A string literal is two bytes; a character constant is an int, four bytes on typical platforms.

5. char s[] = "ab\0cd";
   printf("%zu %zu\n", sizeof s, strlen(s));

   Show answer

   Output: 6 2

   The array holds a, b, NUL, c, d and the final NUL, but strlen stops at the first NUL.

6. char s[] = "hello";
   s[0] = 'J';
   puts(s);

   Show answer

   Output: Jello

   The array is a writable copy, so the edit is allowed.

7. printf("Pin" "Out" "\n");

   Show answer

   Output: PinOut

   Adjacent literals are joined by the compiler.

8. const char *p = "hello";
   printf("%c%c\n", *p, *(p + 4));

   Show answer

   Output: ho

   The first and the fifth characters.

9. char s[] = "cat";
   char *p = s;
   p++;
   printf("%s\n", p);

   Show answer

   Output: at

   p now points at the second character, and %s prints from there to the terminator.

10. printf("%.3s|\n", "firmware");

    Show answer

    Output: fir|

    The precision limits the output to three bytes.

Programming Challenges

Write each one as a function with its own main test, and compile with -Wall -Wextra.

1. Count vowels. Return how many of a, e, i, o, u appear in a string. For "firmware" the answer is 3.
2. Reverse in place. Reverse a writable char array using two pointers that move toward each other. "UART" becomes "TRAU". Remember that a literal cannot be reversed; copy it first.
3. Write your own compare. Implement ep_strcmp that returns zero when two strings are equal and a negative or positive value otherwise, without calling the library.

C Strings Interview Questions With Answers

size_t ep_len(const char *s)
{
    const char *p = s;
    while (*p != '\0')
        p++;
    return (size_t)(p - s);
}

Best Practices, Performance and Security Recap

• Use const char * for literals, arrays for text you edit, and capacity equal to longest text plus one.
• Bound every read and every copy, and trust no external string to be terminated.
• Performance: keep literals in flash, avoid repeated strlen calls, and avoid copying text you only need to read.
• Security: overflows from unbounded input are among the most exploited bugs in C. Widths, fgets and snprintf are your tools.

Summary and Conclusion

You have finished the Strings chapter of the free C programming course. You know that C text is bytes plus a terminator, that quoted literals are read-only arrays that behave like pointers, that your own string variables need one spare byte, that loops end on the NUL, and that input functions need limits. The lab showed these ideas working together in a command matcher, and the quiz and interview questions gave you a way to check your understanding the way an interviewer would.

Next in the free embedded C course comes the standard string library: strlen, strcpy, strcmp, strcat and their safer relatives. With the memory picture from this chapter, each of those functions will feel like a short loop you could have written yourself, because it is.

Frequently Asked Questions