std::initializer_list有点特殊。特别是（来自cppreference）：
std::initializer_list对象在以下情况下自动构造：

• 花括号初始化列表用于列表初始化对象，其中相应的构造函数接受std::initializer_list参数
• 花括号初始化列表用作赋值的右操作数或函数调用参数，相应的赋值运算符/函数接受std::initializer_list参数
• 大括号初始化列表绑定到auto，包括在范围for循环中

bit_representation({1,2,3,4})不是这些。{1,2,3,4}不是std::initializer_list。只有在特定的上下文中，{1,2,3,4}才会自动构造std::initializer_list。在所有其他上下文中，{1,2,3,4}没有可以推导出的类型。
你可以像这样用std::initializer_list调用这个函数：

bit_representation(std::initializer_list<int>{1,2,3,4});

此外，考虑到任何对象都可以被视为字节数组。不需要复制到数组。这是由于char、byte和unsigned char的严格混叠例外，如下所述：https://en.cppreference.com/w/cpp/language/reinterpret_cast。同样不清楚的是，为什么你的函数没有直接使用它的参数type（相当容易误导的名字），而是在复制到数组之前做了另一个不必要的复制tmp。
这可能会给予你一个更好的开始（未经测试）：

std::string bit_representation(const T& t) {
       unsigned char* byte_repr = reinterpret_cast<unsigned char*>(&t);
       for (size_t i=0; i< sizeof(T); ++i) {
            byte_repr[i]; // <- i-th byte of t
            // ...

最终，这个解决方案出现了，但我不确定它是否正确解决方案

template<typename T>
std::string bit_representation(T &&type) {
    auto ptr = reinterpret_cast<const uint8_t *>(&type);
    auto get_byte_repr = [](uint8_t byte) -> std::string {
        std::string s;
        constexpr size_t byte_size = sizeof(uint8_t) * 8;
        s.resize(byte_size);
        for (int i = byte_size - 1; i >= 0; --i) {
            s[i] = ((byte & 1) == 1) ? '1' : '0';
            byte >>= 1;
        }
        return s;
    };
    std::string result;
    for (int i = sizeof(T) - 1; i >= 0; --i) {
        result += get_byte_repr(ptr[i]);
    }
    return result;
}

template<typename T>
std::string bit_representation(std::initializer_list<T> ilist) {
    std::string result;
    for (const auto item: ilist) {
        result += bit_representation(item);
    }
    return result;
}

输出

unsigned short carr[] = {0xDEAD, 0xBEEF};
    struct mZ {
        mZ(uint8_t value) {
            auto ptr = reinterpret_cast<uint8_t *>(this);
            std::fill(ptr, ptr + 1, value);
        }

        mZ() = delete;

        mZ(const mZ &o) = delete;

        mZ(mZ &&o) = default;

        uint8_t a: 1;
        uint8_t b: 1;
        uint8_t c: 1;
        uint8_t d: 1;
        uint8_t e: 1;
        uint8_t f: 1;
        uint8_t g: 1;
        uint8_t h: 1;
    };
    
    /*1111111110101010*/
    std::cout << bit_representation((short) 0xFFAA) << std::endl;
    /*11111110*/
    std::cout << bit_representation(mZ(254)) << std::endl;
    /*00000000000000000000000000000001000000000000000000000000000000100000000000000000000000000000001100000000000000000000000000000100*/
    std::cout << bit_representation({1, 2, 3, 4}) << std::endl;
    /*10111110111011111101111010101101*/
    std::cout << bit_representation(carr) << std::endl;