Do I need to cast to unsigned char before calling toupper(), tolower(), et al.?

by

Yes, the argument to toupper needs to be converted to unsigned char to avoid the risk of undefined behavior.

The types char, signed char, and unsigned char are three distinct types. char has the same range and representation as either signed char or unsigned char. (Plain char is very commonly signed and able to represent values in the range -128..+127.)

The toupper function takes an int argument and returns an int result. Quoting the C standard, section 7.4 paragraph 1:

In all cases the argument is an int, the value of which shall be
representable as an unsigned char or shall equal the value of
the macro EOF . If the argument has any other value, the
behavior is undefined.

(C++ incorporates most of the C standard library, and defers its definition to the C standard.)

The [] indexing operator on std::string returns a reference to char. If plain char is a signed type, and if the value of name[0] happens to be negative, then the expression

toupper(name[0])

has undefined behavior.

The language guarantees that, even if plain char is signed, all members of the basic character set have non-negative values, so given the initialization

string name = "Niels Stroustrup";

the program doesn’t risk undefined behavior. But yes, in general a char value passed to toupper (or to any of the functions declared in <cctype> / <ctype.h>) needs to be converted to unsigned char, so that the implicit conversion to int won’t yield a negative value and cause undefined behavior.

The <ctype.h> functions are commonly implemented using a lookup table. Something like:

// assume plain char is signed
char c = -2;
c = toupper(c); // undefined behavior

may index outside the bounds of that table.

Note that converting to unsigned:

char c = -2;
c = toupper((unsigned)c); // undefined behavior

doesn’t avoid the problem. If int is 32 bits, converting the char value -2 to unsigned yields 4294967294. This is then implicitly converted to int (the parameter type), which probably yields -2.

toupper can be implemented so it behaves sensibly for negative values (accepting all values from CHAR_MIN to UCHAR_MAX), but it’s not required to do so. Furthermore, the functions in <ctype.h> are required to accept an argument with the value EOF, which is typically -1.

The C++ standard makes adjustments to some C standard library functions. For example, strchr and several other functions are replaced by overloaded versions that enforce const correctness. There are no such adjustments for the functions declared in <cctype>.

More Related Contents:

  1. Accessing inactive union member and undefined behavior?
  2. When does invoking a member function on a null instance result in undefined behavior?
  3. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  4. Optimizing away a “while(1);” in C++0x
  5. Does initialization entail lvalue-to-rvalue conversion? Is `int x = x;` UB?
  6. Is `reinterpret_cast`ing between hardware SIMD vector pointer and the corresponding type an undefined behavior?
  7. Why does left shift operation invoke Undefined Behaviour when the left side operand has negative value?
  8. Does “Undefined Behavior” really permit *anything* to happen? [duplicate]
  9. Where exactly does C++ standard say dereferencing an uninitialized pointer is undefined behavior?
  10. Difference between Undefined Behavior and Ill-formed, no diagnostic message required
  11. Is passing a C++ object into its own constructor legal?
  12. Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11
  13. Does not evaluating the expression to which sizeof is applied make it legal to dereference a null or invalid pointer inside sizeof in C++?
  14. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  15. Why can’t “transform(s.begin(),s.end(),s.begin(),tolower)” be complied successfully?
  16. So why is i = ++i + 1 well-defined in C++11?
  17. Why is f(i = -1, i = -1) undefined behavior?
  18. Implementing a std::vector like container without undefined behavior
  19. Are pointer variables just integers with some operators or are they “symbolic”?
  20. The behaviour of floating point division by zero
  21. Can branches with undefined behavior be assumed unreachable and optimized as dead code?
  22. Dangling references and undefined behavior
  23. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  24. Observable behavior and undefined behavior — What happens if I don’t call a destructor?
  25. Is `long` guaranteed to be at least 32 bits?
  26. How is P0522R0 breaking code?
  27. Can class template constructors have a redundant template parameter list in c++20
  28. When a float variable goes out of the float limits, what happens?
  29. Do C++ enums Start at 0?
  30. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?

Leave a Comment