C String strupr() Function

What You’ll Learn

The strupr() function converts every lowercase letter in a C string to uppercase in place. It is a convenient extension on some compilers, but beginners should also learn the portable toupper() loop that works everywhere.

Definition and Usage

strupr walks a modifiable null-terminated string and replaces each lowercase letter with its uppercase equivalent. Digits, spaces, and punctuation stay as they are. The function returns the same pointer you passed in because the transformation happens inside the original buffer.

For example, "Hello, C!" becomes "HELLO, C!"—only the letters H, e, l, l, and o change case.

📝 Syntax

Common extension declaration (availability varies by compiler):

char *strupr(char *str);

Parameters

• str — pointer to a modifiable, null-terminated string to convert.

Return Value

• Pointer to str after in-place conversion (same address as the input).

Headers

• strupr / _strupr — <string.h> on toolchains that provide the extension.
• Portable alternative — <ctype.h> for toupper().

Examples Gallery

Examples use the portable toupper helper so they compile on Linux, macOS, and Windows. Where _strupr exists, it behaves the same way in place.

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

void str_to_upper(char *s) {
    for (; *s; s++) {
        *s = (char)toupper((unsigned char)*s);
    }
}

int main(void) {
    char text[] = "Hello, C!";

    str_to_upper(text);

    printf("Uppercase String: %s\n", text);

    return 0;
}

Uppercase String: HELLO, C!

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

void str_to_upper(char *s) {
    for (; *s; s++) {
        *s = (char)toupper((unsigned char)*s);
    }
}

int main(void) {
    const char *original = "Hello, C!";
    char buffer[32];

    strcpy(buffer, original);
    str_to_upper(buffer);

    printf("Original:  %s\n", original);
    printf("Uppercase: %s\n", buffer);

    return 0;
}

Original:  Hello, C!
Uppercase: HELLO, C!

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

void str_to_upper(char *s) {
    for (; *s; s++) {
        *s = (char)toupper((unsigned char)*s);
    }
}

int main(void) {
    char title[] = "welcome to codetofun";

    str_to_upper(title);

    printf("======== %s ========\n", title);

    return 0;
}

======== WELCOME TO CODETOFUN ========

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

int main(void) {
    char letters[] = "a B c";

    for (int i = 0; letters[i]; i++) {
        unsigned char c = (unsigned char)letters[i];
        printf("'%c' -> '%c'  ", letters[i], (char)toupper(c));
    }
    printf("\n");

    return 0;
}

'a' -> 'A'  ' ' -> ' '  'B' -> 'B'  ' ' -> ' '  'c' -> 'C'  

/* Windows / MSVC example */
#include <stdio.h>
#include <string.h>

int main(void) {
    char buf[] = "Hello, C!";

#if defined(_MSC_VER)
    _strupr(buf);
    printf("Uppercase: %s\n", buf);
#else
    printf("_strupr is not available on this platform.\n");
    printf("Use the portable toupper loop instead.\n");
#endif

    return 0;
}

Uppercase: HELLO, C!

🚀 Common Use Cases

• Display formatting — print headings or labels in uppercase.
• Normalized keys — store identifiers in one case for lookup tables.
• Simple protocol tokens — fold HTTP method names or command verbs.
• Teaching case folding — connect character functions to whole-string transforms.
• Legacy code — read programs that call strupr on Windows toolchains.

📝 Notes

• Not part of ISO C—treat as a vendor extension unless your docs guarantee it.
• Modifies the buffer in place; requires a writable char[], not a literal.
• Uses the current C locale rules inside toupper—ASCII-centric in typical tutorials.
• For case-insensitive comparison without mutation, prefer strcasecmp() or _stricmp().
• Pair conceptually with strlwr() for the opposite transformation.

⚡ Optimization

Uppercasing a string is O(n) in the length of the text. For short identifiers the cost is negligible. Avoid repeated uppercasing of the same string in a hot loop—fold once and reuse the result.

💡 Best Practices