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 <climits>.
• 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.

#include <iostream>
#include <type_traits>

// 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, signed char>; 
    
    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 <cstdint>. 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.

#include <cstdint>
#include <type_traits>

// On platforms with 8-bit bytes, this evaluates to true
static_assert(std::is_same_v<int8_t, signed char>);

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.

// 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 <iostream> 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.

#include <iostream>

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<int>(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.

#include <type_traits>

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<decltype(result), int>);

Master C++ with Deep Grasping Methodology!

Learn More