5.3 Template Specialization and the std::vector<bool> Trap

Sometimes the generic template blueprint does not work for a specific type. For instance, you might want to optimize memory layouts when dealing with boolean flags. C++ allows you to write a custom implementation for a specific type using Template Specialization.

Let's look at template specialization, compile time branching, and why the standard library's boolean vector specialization is considered a major design hazard.

To specialize a template, you write an empty template <> declaration followed by the target type inside angle brackets:

#include <iostream>

// Generic template
template <typename T>
class Printer {
public:
    void print(T val) {
        std::cout << "Generic print: " << val << '\n';
    }
};

// Specialization for char
template <>
class Printer<char> {
public:
    void print(char val) {
        std::cout << "Specialized char print: '" << val << "'\n";
    }
};

In C++17, you can use if constexpr to perform branching at compile time. This allows the compiler to discard branches of code based on type traits, avoiding the need to write separate specialized classes:

#include <iostream>
#include <type_traits>

template <typename T>
void display(T val) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "Integer value: " << val << '\n';
    } else {
        std::cout << "Non integer value: " << val << '\n';
    }
}

C++ specifies that std::vector is a standard sequence container. However, the standard library creators decided to specialize std::vector<bool> to save memory. Instead of using 1 byte of RAM per boolean variable (which is standard), it packs 8 booleans into a single byte (1 bit per boolean flag).

This sounds like a great optimization, but it broke fundamental C++ behavior. Because C++ cannot address individual bits directly, you cannot obtain a raw reference bool& or pointer bool* to a single bit. Therefore:

* std::vector<bool>::operator[] does not return a real reference bool&.

* Instead, it returns a temporary proxy object that simulates a reference.

* This proxy object breaks generic templates that expect to store or return references to container elements, leading to compilation failures and silent bugs.

#include <vector>

int main() {
    std::vector<bool> vec{true, false};
    
    //  COMPILER WARNING / ERROR: Cannot bind a non const reference to a bit proxy!
    // bool& ref = vec[0]; 
    
    // Safe alternative: use copy or const reference
    bool val = vec[0];
    return 0;
}

To avoid this trap, systems developers who need generic container properties often use std::vector<char> or standard bitsets instead of boolean vectors.