删除模板类构造函数后特化版本在GCC与Clang中行为差异分析

我创建了一个删除了默认构造函数的模板类Foo，并对int类型做了特化，目标是只允许实例化int类型的Foo对象。但发现当模板类的成员m_what未初始化时，GCC和Clang的表现不一致；如果初始化该成员，行为就符合预期。

代码如下：

#include <iostream>

template<typename T>
struct Foo
{
    Foo() = delete;

    void print()
    {
        std::cout << m_what << std::endl;
    }

private:
    T m_what; //{666}; // 初始化此成员时行为符合预期
};

template<>
Foo<int>::Foo() : m_what{999}
{
    std::cout << "Contructor INT" << std::endl;
}

int main()
{
    Foo<int> bar;
    bar.print();
    return 0;
}

我的预期输出是：

Program returned: 0
Contructor INT
999

但实际得到的输出是：

Program returned: 0
722345512

请问该如何解释这种差异？仅允许特化类型实例化的最优解决方案是什么？我的目标是禁止任意类型的实例化，只允许特化类型。

1. 编译器行为差异的原因 #

你遇到的核心问题是显式特化的构造函数未被正确调用。

当模板类成员m_what未初始化时，GCC在处理Foo<int>实例化时，未正确关联你定义的特化构造函数，导致Foo<int> bar;没有调用特化构造函数，而是对int类型成员做了默认初始化（即未初始化，值为随机垃圾值）。而Clang则正确识别了特化构造函数的优先级，会正常调用它。

当给m_what加上类内初始化{666}后，主模板的默认构造函数虽被删除，但Foo<int>的特化构造函数明确完成了成员初始化，此时编译器会强制调用特化构造函数，两种编译器的行为就统一符合预期了。这种差异属于编译器在模板特化构造函数匹配逻辑上的实现细节问题。

2. 仅允许特化类型实例化的最优方案 #

要彻底禁止主模板的实例化，只允许显式特化类型，推荐两种可靠方案：

方案一：主模板仅声明不定义 #

#include <iostream>

// 主模板仅声明，不提供定义
template<typename T>
struct Foo;

// 仅对int类型做完整特化定义
template<>
struct Foo<int>
{
    Foo() : m_what{999}
    {
        std::cout << "Constructor INT" << std::endl;
    }

    void print()
    {
        std::cout << m_what << std::endl;
    }

private:
    int m_what;
};

int main()
{
    Foo<int> bar;
    bar.print();
    // Foo<double> baz; // 编译错误：使用不完整类型
    return 0;
}

这种方式最直接，任何尝试实例化非特化类型的代码都会触发编译错误，因为编译器找不到类的定义。

方案二：主模板中添加静态断言（C++11及以上） #

如果需要保留主模板的部分接口，但给用户更友好的错误提示，可以用static_assert：

#include <iostream>

template<typename T>
struct Foo
{
    // 只要实例化主模板就触发编译错误，提示明确信息
    static_assert(false, "Only Foo<int> is allowed to be instantiated");

    Foo() = delete;
    void print();

private:
    T m_what;
};

// 特化int类型的完整定义
template<>
struct Foo<int>
{
    Foo() : m_what{999}
    {
        std::cout << "Constructor INT" << std::endl;
    }

    void print()
    {
        std::cout << m_what << std::endl;
    }

private:
    int m_what;
};

int main()
{
    Foo<int> bar;
    bar.print();
    // Foo<double> baz; // 编译错误：触发static_assert提示
    return 0;
}

这两种方案都能彻底避免编译器行为差异的问题，是实现“仅允许特化类型实例化”的最优选择。

内容的提问来源于stack exchange，提问作者chege54