C-Style Strings

Learn about C-style strings, which are character arrays terminated with a null character, and understand how they work at a fundamental level.

A Simple Example

#include <iostream>

int main() {
    // String literal automatically adds '\0'
    char greeting[] = "Hello";
    // Actually stored as: {'H', 'e', 'l', 'l', 'o', '\0'}

    std::cout << greeting << "\n";  // Prints: Hello

    // Manual character array initialization
    char name[6] {'J', 'o', 'h', 'n', '\0'};
    std::cout << name << "\n";  // Prints: John

    return 0;
}

Breaking It Down

Null Terminator '\0'

• What it is: A special character with value 0 that marks the end of a string
• Why it matters: Functions like std::cout know when to stop printing
• Size consideration: "CAT" needs 4 bytes: 'C', 'A', 'T', and '\0'
• Remember: Without null terminator, functions will read past the array into garbage memory

Character Arrays vs String Literals

• String literals like "Hello" automatically include '\0'
• Manual arrays must explicitly include space for '\0'
• char str[6] = "Hello" creates array with 'H', 'e', 'l', 'l', 'o', '\0'
• Remember: Always allocate one extra space for the null terminator

Common C-String Functions (from <cstring>)

• strlen(str): Returns length without counting '\0'
• strcpy(dest, src): Copies src to dest (dangerous without size checks)
• strcmp(str1, str2): Compares strings (returns 0 if equal)
• strcat(dest, src): Concatenates src to end of dest

Safety Concerns

• Buffer overflow: strcpy/strcat don't check bounds
• Use safer versions: strncpy, strncat with size limits
• Modern C++ prefers std::string for safety
• Remember: C-style strings require manual memory management

Why This Matters

• While modern C++ offers std::string, understanding C-style strings is crucial because they're still used in legacy code, system programming, interfacing with C libraries, and understanding how strings work at a lower level.
• Many C++ functions and APIs still use them, especially when working with operating systems or embedded systems.

Critical Insight

When you print a C-style string with std::cout, it doesn't need to know the array size. It just keeps printing characters until it hits '\0'. That's why the null terminator is crucial - without it, printing will continue into unknown memory, potentially causing crashes or security vulnerabilities!

Think of '\0' as a stop sign at the end of the string. Functions drive along reading characters until they see the stop sign.

Best Practices

Always allocate space for null terminator: When declaring char arrays for strings, add 1 to the string length for '\0'.

Use safer string functions: Prefer strncpy, strncat over strcpy, strcat to prevent buffer overflows.

Consider std::string instead: Modern C++ code should prefer std::string which handles memory automatically.

Initialize arrays properly: Either use string literals or manually add '\0' at the end.

Common Mistakes

Forgetting space for null terminator: char str[3] = "CAT" is wrong. You need char str[4] to include '\0'.

Buffer overflow with strcpy/strcat: These functions don't check bounds. Use strncpy/strncat or std::string instead.

Comparing strings with ==: This compares pointers, not content. Use strcmp() to compare C-string content.

Not initializing to empty string: Uninitialized char arrays contain garbage. Use char str[10] = ""; to start with an empty string.

Using strlen in loop condition: strlen() counts characters every time. Store it in a variable before the loop for better performance.

Debug Challenge

This code declares space for "CAT". Click the highlighted line to fix the array size:

1 #include <iostream>

2

3 int main() {

4 char word[3] = "CAT";

5 std::cout << word << "\n";

6 return 0;

7 }

char word[4] = "CAT"; char word[3] = "CAT"; char word[5] = "CAT"; char word[2] = "CAT";

Quick Quiz

1. What is the size needed for the array to store "CAT"?

4

3

5

You need 4 characters: 'C', 'A', 'T', and '\0' (null terminator). The null terminator is always required and takes up one position.

2. What does strcmp("apple", "banana") return?

Negative number

0

Positive number

strcmp returns a negative number when the first string is lexicographically less than the second. Since "apple" comes before "banana" alphabetically, it returns negative.

3. What happens with this code: char str[10]; strcpy(str, "Hello"); strcpy(str, "World");?

Prints "World"

Prints "HelloWorld"

Buffer overflow

The second strcpy replaces the first string completely. It prints "World". The first strcpy stores "Hello\0", then the second overwrites it with "World\0".

Check Answers Try Again

Practice Playground

Time to try out what you just learned! Play with the example code below, experiment by making changes and running the code to deepen your understanding.

Run Code Reset

Output:

Error:

Lesson Progress

• Fix This Code
• Quick Quiz
• Practice Playground - run once

Complete Lesson