> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ signed char A fundamental integral data type in C++ that occupies exactly one byte of memory and is explicitly defined to represent signed integer values. Unlike the standard `char` type, whose signedness is implementation-defined (determined by the compiler and target architecture), `signed char` is strictly guaranteed to hold both negative and positive values. ## Technical Specifications * **Size:** `sizeof(signed char)` is always exactly `1`. * **Bit Width:** Guaranteed to be at least 8 bits, determined by the `CHAR_BIT` macro in ``. * **Value Range:** The standard guarantees a minimum range of `-127` to `127`. On virtually all modern architectures utilizing 8-bit bytes, the range is exactly `-128` to `127`. * **Memory Representation:** As of C++20, the standard strictly mandates two's complement representation for all signed integral types, including `signed char`. ## Type Distinctness In the C++ type system, `char`, `signed char`, and `unsigned char` are three mutually exclusive, distinct types. Even if a compiler implements the standard `char` as signed by default, `char` and `signed char` are not the same type. This distinction is critical during function overloading, template instantiation, and type deduction. ```cpp theme={"dark"} #include #include // These are three distinct function overloads void printType(char c) { std::cout << "char\n"; } void printType(signed char c) { std::cout << "signed char\n"; } void printType(unsigned char c) { std::cout << "unsigned char\n"; } int main() { // Evaluates to false, proving they are distinct types at the compiler level constexpr bool is_same = std::is_same_v; char a = 'A'; signed char b = -50; printType(a); // Resolves to printType(char) printType(b); // Resolves to printType(signed char) return 0; } ``` ## Relationship to Fixed-Width Integer Types In modern C++, the raw `signed char` type is closely tied to the fixed-width integer types defined in ``. The type `int8_t` is an exact-width 8-bit signed integer type that is almost universally implemented by compilers as a `typedef` (or type alias) for `signed char`. Understanding this relationship is essential, as `int8_t` inherits all the distinct behaviors of `signed char`. ```cpp theme={"dark"} #include #include // On platforms with 8-bit bytes, this evaluates to true static_assert(std::is_same_v); ``` ## Syntax and Initialization `signed char` can be initialized using character literals, integer literals, or brace-enclosed uniform initialization. When initialized with an integer literal outside its representable range, a narrowing conversion occurs. ```cpp theme={"dark"} // Standard initialization signed char val1 = 'A'; // Stores the ASCII integer value of 'A' (65) signed char val2 = -120; // Direct integer assignment // Uniform initialization (strictly prevents narrowing conversions) signed char val3{42}; // Valid // signed char val4{200}; // Compiler error: narrowing conversion from int to signed char // Pointer and reference syntax signed char* ptr = &val1; const signed char& ref = val2; ``` ## Standard I/O Stream Behavior Because `` treats `signed char` (and its alias `int8_t`) as a character type rather than a standard numeric integer, passing it to standard output streams will print its character representation. For negative values or non-printable control characters, this results in unprintable output or garbage characters rather than the numeric integer value. To print the actual numeric value, the `signed char` must be explicitly cast or promoted to an `int`. ```cpp theme={"dark"} #include int main() { signed char val = -42; // Prints a non-printable character (or garbage), not "-42" std::cout << val << '\n'; // Unary '+' forces integral promotion to 'int', printing "-42" std::cout << +val << '\n'; // Explicit cast to 'int' also prints "-42" std::cout << static_cast(val) << '\n'; return 0; } ``` ## Arithmetic and Integral Promotion Because `signed char` has a lower integer conversion rank than `int`, it is subject to **integral promotion**. When used in arithmetic, logical, or bitwise operations, a `signed char` operand is implicitly promoted to an `int` (or `unsigned int` if `int` cannot represent the entire range, though `int` always can for an 8-bit `signed char`) before the operation is evaluated. ```cpp theme={"dark"} #include signed char x = 100; signed char y = 50; // x and y are promoted to int before the addition occurs. // The result is an int (150), preventing overflow during the intermediate calculation. auto result = x + y; // Proves the resulting type is int, not signed char static_assert(std::is_same_v); ```

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More