Strings

🎸 Strings in C: The Magic Necklace of Characters

Imagine you have a necklace made of colorful beads. Each bead is a letter. When you put them together on a string, they spell a word! That’s exactly what a string is in C—a necklace of characters.

🌟 What is a String in C?

A string is just a bunch of letters (characters) sitting together in a row. Like beads on a necklace!

char name[] = "Hello";

This creates a necklace with 5 beads: H, e, l, l, o.

But wait! There’s a secret invisible bead at the end. Let’s find out what it is!

🏷️ String Literals vs char Arrays

String Literal = A Sign You Can Look At (But Not Touch!)

A string literal is like a museum painting. You can see it, but you cannot change it!

char *sign = "Keep Out";
// sign points to text in read-only memory
// Trying to change it = CRASH! 💥

char Array = Your Own Toy Box (Change It Anytime!)

A char array is like your personal toy box. You OWN it. You can move things around!

char toybox[] = "Hello";
// Your own copy - change it freely!
toybox[0] = 'J';  // Now it's "Jello"

Golden Rule: If you want to change it, use a char array!

🔚 The Null Terminator: The Invisible End Marker

Every string necklace has a secret invisible bead at the end called the null terminator (\0).

Think of it like a STOP sign 🛑 that tells C: “The word ends here!”

char word[] = "Cat";
// What's really stored:
// ['C']['a']['t']['\0']
//   0    1    2    3

Why do we need it?

Without the stop sign, C would keep reading garbage beyond your word—like a car driving off the road!

graph TD
    A["C"] --> B["a"]
    B --> C["t"]
    C --> D["\\0 STOP!"]
    D --> E["End of String"]

📥📤 String Input and Output

Printing Strings (Output)

Use printf with %s to show your string:

char greeting[] = "Hello World!";
printf("%s\n", greeting);
// Output: Hello World!

Reading Strings (Input)

Option 1: scanf (Stops at space)

char name[50];
scanf("%s", name);
// Type "John Doe" → Gets only "John"

Option 2: fgets (Gets the whole line!)

char sentence[100];
fgets(sentence, 100, stdin);
// Type "John Doe" → Gets "John Doe\n"

Pro Tip: Always use fgets for real programs. It’s like wearing a seatbelt!

🧰 String Functions (Your Toolbox!)

C gives you a magic toolbox called <string.h>. Here are your super tools:

strlen() - Count the Beads

#include <string.h>
char word[] = "Apple";
int len = strlen(word);  // len = 5

strcpy() - Copy a Necklace

char source[] = "Hello";
char dest[20];
strcpy(dest, source);  // dest = "Hello"

strcat() - Connect Two Necklaces

char first[20] = "Good ";
char second[] = "Morning";
strcat(first, second);  // "Good Morning"

strcmp() - Are They Twins?

int result = strcmp("cat", "cat");  // 0 = same!
int result2 = strcmp("cat", "dog"); // not 0 = different

📏 strlen vs sizeof: The Great Mystery!

This confuses EVERYONE. Let’s clear it up with a story!

strlen = Count only the visible beads (characters) sizeof = Count the whole box (including empty space + stop sign)

char word[] = "Hello";

strlen(word);  // 5 (just the letters)
sizeof(word);  // 6 (letters + \0)

Another Example:

char box[20] = "Hi";

strlen(box);  // 2 (just "Hi")
sizeof(box);  // 20 (the whole box size!)

graph TD
    A["char word[] = 'Hello'"] --> B["strlen = 5"]
    A --> C["sizeof = 6"]
    B --> D["Counts: H-e-l-l-o"]
    C --> E["Counts: H-e-l-l-o-\\0"]

Memory Trick:

• strlen = “String LENGTH” = just the text
• sizeof = “SIZE of the box” = everything!

🎨 sprintf and sscanf: Magic Converters!

sprintf - Write to a String (Like Magic Painting!)

Instead of printing to screen, paint into a string!

char message[50];
int age = 10;
sprintf(message, "I am %d years old", age);
// message = "I am 10 years old"

sscanf - Read from a String (Like X-Ray Vision!)

Pull numbers and words OUT of a string!

char data[] = "Score: 100";
int score;
sscanf(data, "Score: %d", &score);
// score = 100

Real-World Example:

// Building a filename
char filename[100];
int level = 5;
sprintf(filename, "game_level_%d.txt", level);
// filename = "game_level_5.txt"

// Parsing a config line
char config[] = "width=800";
char key[20];
int value;
sscanf(config, "%[^=]=%d", key, &value);
// key = "width", value = 800

🏆 Quick Summary

graph LR
    A["Strings in C"] --> B["String Literal<br/>Read-only"]
    A --> C["char Array<br/>Changeable"]
    A --> D["Null Terminator<br/>\\0 ends string"]
    A --> E["I/O<br/>printf, scanf, fgets"]
    A --> F["Functions<br/>strlen, strcpy, strcat, strcmp"]
    A --> G["strlen vs sizeof<br/>Text vs Box size"]
    A --> H["sprintf/sscanf<br/>Convert to/from strings"]

🎯 Key Takeaways

1. Strings = Character arrays ending with \0
2. String literals are read-only - use char arrays to modify
3. Always include \0 - C needs that stop sign!
4. fgets is safer than scanf for input
5. strlen counts characters, sizeof counts total memory
6. sprintf builds strings, sscanf extracts data

💡 Remember: A string is just a necklace of character beads with an invisible stop-bead at the end. Master this, and you’ve mastered strings! 🎸