C String strlwr() Function

What You’ll Learn

The strlwr() function converts uppercase letters in a C-string to lowercase in place. It is not ISO C standard—many compilers expose it as an extension (often as _strlwr on Windows). This tutorial also shows the portable tolower() loop every platform supports.

Definition and Usage

strlwr stands for string lower. It scans a null-terminated string and replaces each uppercase ASCII letter with its lowercase form. Digits, spaces, punctuation, and already-lowercase letters stay the same.

Because it modifies the buffer you pass in, copy the string first if you need to preserve the original text. Never pass a string literal—that memory is read-only and modifying it causes undefined behavior.

📝 Syntax

Typical extension declaration:

char *strlwr(char *str);
/* MSVC documented form: */
char *_strlwr(char *str);

Portable alternative

#include <ctype.h>

void str_to_lower(char *s) {
    for (; *s; s++) {
        *s = (char)tolower((unsigned char)*s);
    }
}

Parameter

• str — writable null-terminated string to convert.

Return Value

• Returns str (pointer to the modified buffer).

Examples Gallery

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

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

void str_to_lower(char *s) {
    for (; *s; s++) {
        *s = (char)tolower((unsigned char)*s);
    }
}

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

    str_to_lower(text);

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

    return 0;
}

Lowercase String: hello, c programming!

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

void str_to_lower(char *s) {
    for (; *s; s++) {
        *s = (char)tolower((unsigned char)*s);
    }
}

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

    strcpy(buffer, original);
    str_to_lower(buffer);

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

    return 0;
}

Original:  Hello, C Programming!
Lowercase: hello, c programming!

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

void str_to_lower(char *s) {
    for (; *s; s++) {
        *s = (char)tolower((unsigned char)*s);
    }
}

int main(void) {
    char cmd[] = "QuIt";

    str_to_lower(cmd);

    if (strcmp(cmd, "quit") == 0) {
        printf("Goodbye!\n");
    } else {
        printf("Unknown: %s\n", cmd);
    }

    return 0;
}

Goodbye!

#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)tolower(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 Programming!";

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

    return 0;
}

Lowercase: hello, c programming!

🚀 Common Use Cases

• Canonical keys — store map or dictionary keys in one case.
• User commands — normalize input before lookup.
• Filename handling — on case-insensitive file systems.
• Simple parsers — treat TRUE and true alike after folding.
• Teaching — connect character functions to whole-string transforms.

📝 Notes

• Not part of ISO C—verify availability or use a tolower loop.
• Modifies the string in place; copy first if needed.
• Never pass string literals or read-only memory.
• Locale-dependent for non-ASCII; not full Unicode case mapping.
• Pair conceptually with strupr() for the reverse transform.

⚡ Optimization

Lowercasing is O(n) in string length. For occasional normalization the simple loop is fine. Avoid repeated lowercasing of the same unchanged string in hot loops—cache the result or compare with case-insensitive helpers instead.

💡 Best Practices