类模板外置构造函数模板在GCC正常编译，Clang中失败

Alright, let's figure out why your code works in GCC but fails in Clang, and fix it properly for cross-compiler compatibility.

The Root Cause #

GCC is cutting you some slack with a non-standard extension, but Clang is strictly following the C++ standard. The problem lies in your attempt to explicitly specialize a member template constructor of a class template.

When you write:

template <> template <>
A<std::string>::A<std::string>(const std::string& s) { ... }

you're trying to specialize the member template constructor of A<std::string> for the case where C = std::string. However, the C++ standard does not allow this kind of explicit specialization for constructor templates. GCC provides an unofficial extension that lets this slide, but Clang rejects it because it's not standard-compliant.

Solution 1: Specialize the Entire Class Template #

The most straightforward fix is to specialize the entire A<std::string> class. This lets you define the exact constructor behavior you want for that type, while retaining the template constructor for other input types:

#include <iostream>
#include <string>

template <typename T>
struct A {
    template <typename C>
    A(const C& c) {
        std::cout << "base" << std::endl;
    }
};

// Full specialization of A for std::string
template <>
struct A<std::string> {
    // Constructor for std::string inputs
    A(const std::string& s) {
        std::cout << s << std::endl;
    }

    // Keep the template constructor for other types
    template <typename C>
    A(const C& c) {
        std::cout << "base" << std::endl;
    }
};

int main() {
    std::string f("foo");
    A<std::string> a(f); // Outputs "foo"
    A<std::string> b(1.2); // Outputs "base"
}

Solution 2: Use SFINAE to Select Constructor Versions #

If you don't want to specialize the entire class, you can use SFINAE (Substitution Failure Is Not An Error) to conditionally enable different constructor versions based on the input type. This keeps everything in the primary template and works across all standard-compliant compilers:

#include <iostream>
#include <string>
#include <type_traits>

template <typename T>
struct A {
    // Enabled when the input type C is NOT the same as T
    template <typename C, std::enable_if_t<!std::is_same_v<T, C>, int> = 0>
    A(const C& c) {
        std::cout << "base" << std::endl;
    }

    // Enabled when the input type C IS the same as T
    template <typename C, std::enable_if_t<std::is_same_v<T, C>, int> = 0>
    A(const C& s) {
        std::cout << s << std::endl;
    }
};

int main() {
    std::string f("foo");
    A<std::string> a(f); // Outputs "foo"
    A<std::string> b(1.2); // Outputs "base"
}

Why This Works #

Both solutions adhere strictly to the C++ standard, so they'll compile and run correctly in both GCC and Clang. The first approach is more explicit for specific type cases, while the second is more scalable if you need this pattern for multiple T types.

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