Is GCC right when it accepts a C++ template struct having a member with a wrong default initializer?

Have you ever written C++ template code that compiled fine with GCC but failed with Clang or MSVC? You're not alone. A recent StackOverflow question highlights a subtle but important compiler discrepancy that every C++ developer should understand.

The Problem: When GCC Accepts Invalid Code

Consider this template struct:

template<typename T>
struct S {
    T x = 1;  // Default initializer
};

At first glance, this looks reasonable. But what if T is a type that can't be initialized with 1? For example:

S<std::string> s;  // Should this compile?

GCC says yes. Clang and MSVC say no. Who's right?

Understanding the Standard

The C++ standard ([dcl.init]/11.6) states that default member initializers must be valid for the type. When T is std::string, T x = 1 is clearly invalid - you can't initialize a string with an integer.

However, GCC implements a controversial extension: it only checks the validity of default initializers when they're actually used, not when the template is instantiated. This is why:

S<int> s1;    // OK - int can be initialized with 1
S<std::string> s2;  // GCC accepts this, but shouldn't

Why This Matters

1. Portability Issues: Code that compiles with GCC may fail with other compilers
2. Silent Bugs: Invalid initializers might go unnoticed until they're actually used
3. Standard Compliance: GCC's behavior violates the C++ standard

Developer Takeaways

1. Be Explicit: Always ensure your default initializers are valid for all possible template arguments
2. Use Static Assertions: Add static_assert checks to validate template arguments
3. Test Multiple Compilers: Don't rely on GCC's permissive behavior
4. Consider -pedantic: Use GCC's strict mode to catch these issues

Best Practices

template<typename T>
struct S {
    T x = T(1);  // Better: explicit construction
    // Or:
    static_assert(std::is_constructible_v<T, int>,
                 "T must be constructible from int");
    T y = 1;
};

Conclusion

While GCC's behavior might seem convenient, it can lead to subtle bugs and portability issues. As C++ developers, we should strive for standard-compliant code that works across all major compilers. Understanding these compiler quirks helps us write more robust template code.

Have you encountered similar compiler discrepancies? Share your experiences in the comments!