What's an alternate way of getting the char's int value to increment?

Question

While in the progress of making string functions, I have tried building a function somewhere similar to strlwr() which I named lowercase():

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

char *lowercase(char *text);

int main() {
    char *hello = "Hello, world!";
    printf("%s\n", lowercase(hello));
}

char *lowercase(char *text) {
    for (int i = 0; ; i++) {
        if (isalpha(text[i])) {
            (int) text[i] += ('a' - 'A');
            continue;
        } else if (text[i] == '\0') {
            break;
        }
    }
    return text;
}

I learned that the gap for a big letter and small letter would be 32, which is what I used. But then I got this error:

lowercase.c:14:13: error: assignment to cast is illegal, lvalue casts are not supported
            (int) text[i] += 32;
            ^~~~~~~~~~~~~ ~~

I want to increment the value of the char if it is considered a letter from A-Z. Turns out I can't, since the char is in an array, and the way I'm doing it doesn't seem to make sense for the computer.

Q: What alternate ways can I use to complete this function? Can you explain further why this error is like this?

Do you want to convert it to `int`, increment it, then jam it back into `char`? If so: `text[i] = (int) text[i] + x`. Keep in mind this is just *begging* for seemingly bizarre overflow bugs because these two representations are significantly different. — tadman, Sep 28 '20 at 16:52
Why not just `text[i] |= 32` and forget about the `int` conversion? — tadman, Sep 28 '20 at 16:54
_Side note:_ As you have it, `hello` _points_ to a string constant [that is probabably loaded into R/O memory]. To allow this to work, do: `char hello[] = "Hello, world!";` Now, the _array_ of chars is on the stack (i.e. modifiable). — Craig Estey, Sep 28 '20 at 16:56
You are likely to run into **undefined behaviour** here, as you are trying to modify (*via* a pointer) a string literal's data (which the compiler is perfectly entitled to store in a read-only code section). — Adrian Mole, Sep 28 '20 at 16:57
Don't hard code `32`. If you're going to do it this way, please, for the sanity of future readers, write `'a' - 'A'` — William Pursell, Sep 28 '20 at 17:18
@WilliamPursell Yeah, I tried some testing for `char` value before making the function, which is why I made this. Thank you for pointing out mistake I made. — BMPL, Sep 28 '20 at 17:22

John Kugelman · Answer 1 · 2020-09-28T17:33:42.623

1

The cast is unnecessary. chars are integral types and can be incremented without fanfare:

text[i] += 32;

As several commenters have noted, you should also change your string to a modifiable string. char *hello = "..." declares a read-only string literal. Use array syntax to make it writable.

char hello[] = "Hello, world!";

You'll also want to switch isalpha() to isupper() so you only modify uppercase letters.

By the way, if you move the else if check into the for loop's test condition you can get rid of both the break and the continue.

for (int i = 0; text[i] != '\0'; i++) {
    if (isupper((unsigned char) text[i])) {
        text[i] += 32;
    }
}

edited Sep 28 '20 at 17:33

answered Sep 28 '20 at 16:54

John Kugelman

349,597
67
533
578

1

Even shorter: `for ( unsigned char *p = text; *p; p++ ) *p = toupper( *p );` – Andrew Henle Sep 28 '20 at 17:54
2

@AndrewHenle There was a bug when BPML posted that comment that I've fixed. – John Kugelman Sep 28 '20 at 17:56

Vlad from Moscow · Accepted Answer · 2020-09-28T17:10:30.933

1

Though in C string literals have types of non-constant character arrays nevertheless you may not change string literals.

char *hello = "Hello, world!";

From the C Standard (6.4.5 String literals)

7 It is unspecified whether these arrays are distinct provided their elements have the appropriate values. If the program attempts to modify such an array, the behavior is undefined.

So you should declare the identifier hello like a character array

char hello[] = "Hello, world!";

Within the function you should not use magic numbers like 32. For example if the compiler uses the EBCDIC coding your function will produce a wrong result.

And in the loop instead of the type int you have to use the type size_t because an object of the type int can be unable to store all values of the type size_t that is the return type of the sizeof operator or of the function strlen.

This statement

(int) text[i] += 32;

does not make a sense because in the left side of the expression there is an rvalue due to the casting.

The function can be implemented the following way

char * lowercase( char *text ) 
{
    for ( char *p = text; *p; ++p ) 
    {
        if ( isalpha( ( unsigned char )*p ) ) 
        {
            *p = tolower( ( unsigned char )*p );
        } 
    }

    return text;
}

edited Sep 28 '20 at 17:10

answered Sep 28 '20 at 17:03

Vlad from Moscow

301,070
26
186
335

Please fix this, what you should've said was `tolower((unsigned char) *p)`. – BMPL Sep 28 '20 at 17:10
@BPML Thanks. I was not attentive. – Vlad from Moscow Sep 28 '20 at 17:11
Why do you cast to `unsigned char`? – John Kugelman Sep 28 '20 at 17:23
1

@JohnKugelman The argument of these functions shall be unsigned char. Otherwise due to the integer promotions you can get undefined behavior. – Vlad from Moscow Sep 28 '20 at 17:25
TIL. [Do I need to cast to unsigned char before calling toupper(), tolower(), et al.?](https://stackoverflow.com/questions/21805674/do-i-need-to-cast-to-unsigned-char-before-calling-toupper-tolower-et-al) – John Kugelman Sep 28 '20 at 17:30
If you use `tolower()` the `isalpha()` check isn't needed. `tolower()` returns non-alphabetic characters unmodified. – John Kugelman Sep 28 '20 at 17:31
@JohnKugelman I agree. It could be done without such a check. – Vlad from Moscow Sep 28 '20 at 17:32

What's an alternate way of getting the char's int value to increment?

2 Answers2