String Manipulations

Programming Language & Its Applications — Introduction to C Programming, NEC licence examination syllabus (Nepal Engineering Council).

String Manipulations: char arrays with a null terminator

C has no string type — only char arrays ending in '\0', and that single design choice explains every string bug in C.

In C a "string" is a char array whose last meaningful byte is '\0' (the null character, value 0). Every library function finds the end by scanning for that byte. So the length is not stored — it is computed — and if the terminator is missing, functions run off the end of your buffer. Understanding this makes both <string.h> and its dangers obvious.

🌍 Where this lives: C's null-terminated string is one of the most consequential design choices ever made. Because the length is not stored, strlen is O(n) — so for(i=0;i<strlen(s);i++) is accidentally O(n²), a real performance bug found in production code constantly. And because every function trusts the terminator, a missing '\0' reads off the end of your buffer: that is the Heartbleed class of vulnerability. Search "why Pascal strings store length" to see the design C rejected and what it cost.

The null terminator

char s[] = "HELLO"; index: 0 1 2 3 4 5 char: 'H' 'E' 'L' 'L' 'O' '\0' value: 72 69 76 76 79 0 sizeof(s) = 6 ← includes the '\0' strlen(s) = 5 ← counts up to but NOT including '\0' ALWAYS: sizeof = strlen + 1 (for a string literal array) Declaration forms: char a[] = "HI"; → 3 bytes, modifiable char b[10] = "HI"; → 10 bytes, rest zero-filled char c[] = {'H','I','\0'}; → same as a char d[] = {'H','I'}; → NOT a string! no terminator char *e = "HI"; → pointer to READ-ONLY literal e[0]='X' is undefined behaviour

strbasics.c

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

int main(void) {
    char s[] = "HELLO";

    printf("sizeof = %zu\n", sizeof s);   /* 6 */
    printf("strlen = %zu\n", strlen(s));  /* 5 */

    for (size_t i = 0; i <= strlen(s); i++)
        printf("[%zu] '%c' = %d\n", i,
               s[i] ? s[i] : ' ', s[i]);

    /* truncating a string: just move the terminator */
    s[3] = '\0';
    printf("after s[3]='\\0': \"%s\" len=%zu\n", s, strlen(s));
    return 0;
}
Output:
sizeof = 6
strlen = 5
[0] 'H' = 72
[1] 'E' = 69
[2] 'L' = 76
[3] 'L' = 76
[4] 'O' = 79
[5] ' ' = 0
after s[3]='\0': "HEL" len=3

The string.h functions

strlen(s) → length, excluding '\0' O(n) strcpy(d, s) → copy s into d, incl '\0' O(n) strncpy(d, s, n) → copy at most n chars strcat(d, s) → append s to d O(n+m) strncat(d, s, n) → append at most n chars strcmp(a, b) → <0 if a<b, 0 if equal, >0 if a>b strncmp(a, b, n) → compare first n chars strchr(s, c) → pointer to first c, or NULL strstr(s, sub) → pointer to first substring, or NULL strtok(s, delim) → split into tokens (MODIFIES s) CRITICAL: strcpy and strcat do NOT check the destination size. If d is too small, they write past its end. This is the buffer-overflow bug class.

strfuncs.c

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

int main(void) {
    char a[40] = "Nepal";
    char b[]   = " Engineering";

    strcat(a, b);
    printf("cat:  %s\n", a);

    char c[40];
    strcpy(c, a);
    printf("copy: %s\n", c);

    /* strcmp compares byte by byte, ASCII order */
    printf("cmp(\"apple\",\"banana\") = %d\n",
            strcmp("apple", "banana"));
    printf("cmp(\"banana\",\"apple\") = %d\n",
            strcmp("banana", "apple"));
    printf("cmp(\"same\",\"same\")     = %d\n",
            strcmp("same", "same"));

    char *p = strstr(a, "Engine");
    if (p) printf("found at index %ld\n", p - a);
    return 0;
}
Output:
cat:  Nepal Engineering
copy: Nepal Engineering
cmp("apple","banana") = -1
cmp("banana","apple") = 1
cmp("same","same")     = 0
found at index 6

How strcmp("apple","banana") gets -1: compare 'a'(97) vs 'b'(98) → 97 − 98 = −1 differs at the first byte, so it stops there. strcmp("apple","apricot"): 'a'=='a', 'p'=='p', then 'p'(112) vs 'r'(114) → −2 NEVER use == to compare strings: if (s1 == s2) ← compares ADDRESSES, almost always false if (strcmp(s1,s2)==0) ← compares CONTENTS ✔

Worked example 1 — writing the functions yourself

myown.c

#include <stdio.h>

size_t my_strlen(const char *s) {
    size_t n = 0;
    while (s[n] != '\0') n++;   /* scan for the terminator */
    return n;
}

void my_strcpy(char *d, const char *s) {
    size_t i = 0;
    while (s[i] != '\0') { d[i] = s[i]; i++; }
    d[i] = '\0';               /* MUST copy the terminator */
}

void reverse(char *s) {
    size_t i = 0, j = my_strlen(s) - 1;
    while (i < j) { char t=s[i]; s[i]=s[j]; s[j]=t; i++; j--; }
}

int is_palindrome(const char *s) {
    size_t i = 0, j = my_strlen(s) - 1;
    while (i < j) { if (s[i] != s[j]) return 0; i++; j--; }
    return 1;
}

int main(void) {
    char s[40] = "PROGRAM";
    printf("len=%zu\n", my_strlen(s));

    char d[40];
    my_strcpy(d, s);
    printf("copy=%s\n", d);

    reverse(s);
    printf("reversed=%s\n", s);

    printf("\"madam\"  palindrome? %d\n", is_palindrome("madam"));
    printf("\"nepal\"  palindrome? %d\n", is_palindrome("nepal"));
    return 0;
}
Output:
len=7
copy=PROGRAM
reversed=MARGORP
"madam"  palindrome? 1
"nepal"  palindrome? 0

Worked example 2 — the buffer overflow

overflow.c

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

int main(void) {
    char small[6];

    /* "Engineering" is 11 chars + '\0' = 12 bytes
       into a 6-byte buffer: 6 bytes written PAST the end */
    /* strcpy(small, "Engineering");   <-- OVERFLOW */

    /* the safe version - bounded, and terminate manually */
    strncpy(small, "Engineering", sizeof small - 1);
    small[sizeof small - 1] = '\0';
    printf("truncated: \"%s\"\n", small);

    /* safest for user input: fgets, which bounds itself */
    char line[64];
    printf("Enter a line: ");
    if (fgets(line, sizeof line, stdin)) {
        line[strcspn(line, "\n")] = '\0';  /* strip newline */
        printf("got %zu chars: %s\n", strlen(line), line);
    }
    return 0;
}
Output:
truncated: "Engin"
Enter a line: hello world
got 11 chars: hello world

Why the overflow is dangerous, not merely wrong: Stack layout (typical): [ small[6] ][ other locals ][ saved regs ][ return addr ] ↑ writing 12 bytes here reaches into ──────┘ Overwriting the return address lets an attacker redirect execution to code of their choosing. This is the classic "stack smashing" attack — the mechanism behind a large share of historical remote-code-execution CVEs. Rules: · never strcpy/strcat into a fixed buffer from untrusted data · never use gets() — it was REMOVED from C11 for this reason · use fgets for input, snprintf for formatting · strncpy does NOT guarantee a terminator: add it yourself

Worked example 3 — word count with strtok

wordcount.c

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

int main(void) {
    char text[] = "Nepal Engineering Council exam 2026";
    int words = 0, vowels = 0, digits = 0, upper = 0;

    for (int i = 0; text[i]; i++) {
        char c = tolower(text[i]);
        if (strchr("aeiou", c) && c) vowels++;
        if (isdigit((unsigned char)text[i])) digits++;
        if (isupper((unsigned char)text[i])) upper++;
    }

    /* strtok MODIFIES the string, inserting '\0' at
       each delimiter - so work on a copy if you need
       the original afterwards */
    char copy[80];
    strcpy(copy, text);
    for (char *t = strtok(copy, " "); t; t = strtok(NULL, " ")) {
        printf("word %d: %s\n", ++words, t);
    }

    printf("words=%d vowels=%d digits=%d upper=%d\n",
           words, vowels, digits, upper);
    return 0;
}
Output:
word 1: Nepal
word 2: Engineering
word 3: Council
word 4: exam
word 5: 2026
words=5 vowels=12 digits=4 upper=4

💡 Exam angle: sizeof vs strlen (differ by 1) is asked every year. Be able to hand-implement strlen, strcpy, strcmp, reverse and palindrome check — these are standard programming questions. Know that strcmp returns the byte difference, that == compares addresses not contents, and that strcpy/gets cause buffer overflows (gets was removed from C11).

Syllabus points

String functions (strlen, strcpy, strcmp, strcat)

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.