C++，C++/CX に挑戦！

// Array.h
template <class Type> class Array { };



// BoolArray.h
// template<> class Array<bool>
// 配列クラステンプレートArray<> を bool型に特殊化
#include <limits>
#include "Array.h"

template<> class Array<bool> {
    typedef unsigned char BYTE;
    static const int CHAR_BITS
        = std::numeric_limits<unsigned char>::digits;
 
    // bool型配列の要素数
    int nelem;

    // bool型配列を格納するためのBYTE型配列の要素数
    int velem;

    // BYTE型先頭要素へのポインタ
    BYTE* vec;

    // バイト型配列要素の必要数を算出
    static int size_of(int sz) {
        return (sz + CHAR_BITS - 1) / CHAR_BITS;
    }

public:
    // 該当バイト中の該当ビットへの参照を表すクラス
    class BitOfByteRef {
        BYTE& vec;      // 参照先BYTE
        int idx;        // 参照先BYTE中のビット番号

    public:
        // コンストラクタ
        BitOfByteRef(BYTE& r, int i)
            : vec(r), idx(i) { }

        // 該当ビットを bool型で返却
        operator bool() const { return (vec >> idx) & 1U; }

        // 該当ビットに true または false をセット
        BitOfByteRef& operator=(bool b) {
            if (b)
                vec |= 1U << idx;
            else
                vec &= ~(1U << idx);
            return *this;
        }
    };

    // 添字範囲エラー
    class IdxRngErr {
        const Array* ident;
        int index;
    public:
        IdxRngErr(const Array* p, int i) : ident(p), index(i) { }
        int Index() const { return index; }
    };

    // コンストラクタ
    explicit Array(int sz, unsigned int v = 0)
        : nelem(sz), velem(size_of(sz)) {
        vec = new BYTE[velem];

        // 全要素を初期化
        for (int i = 0; i < velem; i++)
            vec[i] = v;
    }

    // コピーコンストラクタ
    Array(const Array& x) {
        if (&x == this) {
            nelem = 0;
            vec = NULL;
        }
        else {
            nelem = x.nelem;
            velem = x.velem;
            vec = new BYTE[velem];
            for (int i = 0; i < velem; i++)
                vec[i] = x.vec[i];
        }
    }

    // デストラクタ
    ~Array() { delete[] vec; }

    // 要素数を返す
    int size() const { return nelem; }

    // 代入演算子
    Array& operator=(const Array& x) {
        if (&x != this) {
            if (velem != x.velem) {
                delete[] vec;
                velem = x.velem;
                vec = new BYTE[velem];
            }
            nelem = x.nelem;
            for (int i = 0; i < velem; i++)
                vec[i] = x.vec[i];
        }
        return *this;
    }

    // 添字演算子[]
    BitOfByteRef operator[](int i) {
        if (i < 0 || i >= nelem)
            throw IdxRngErr(this, i);
        return BitOfByteRef(
            vec[i / CHAR_BITS], (i & (CHAR_BITS - 1))
        );
    }

    // 添字演算子[]
        bool operator[](int i) const {
        if (i < 0 || i >= nelem)
            throw IdxRngErr(this, i);
        return
            (vec[i / CHAR_BITS] >> (i & (CHAR_BITS - 1)) & 1U)
            == 1;
    }
};



// BoolArrayTest.cpp
// 配列クラステンプレートArray<bool>の利用
#include <iostream>
#include "BoolArray.h"

using namespace std;

// Array<bool>型配列の全要素を表示
void print_Array_bool(const Array<bool>& a) {
    for (int i = 0; i < a.size(); i++)
        cout << (a[i] ? '1' : '0');
}

int main() {
    Array<bool> a(10);
    a[2] = true;
    cout << boolalpha << a[2] << '\n';
    cout << "a = "; print_Array_bool(a);
    cout << '\n';
}