默认构造函数不同声明引发的链接错误及相关技术疑问

Awesome question—this is a common point of confusion when learning about C++ default constructors, so let's unpack it clearly.

What's the Difference Between the Two Declarations? #

Let's break down each case:

• A() = default;: This is an explicitly defaulted constructor. When you write this, you're telling the compiler: "Generate the exact same default constructor you would have created if I didn't write any constructor at all." The compiler will automatically provide a definition for this constructor when it's needed (like when you instantiate A a;), so the linker can find it and no error occurs. Its behavior matches the implicit default constructor—for your struct A with an int a member, it'll perform trivial initialization (zero-initialized if a is global, uninitialized if it's a local variable, just like the implicit version).
• A();: This is just a declaration of a user-provided constructor. By declaring this, you're telling the compiler: "I'm going to write my own constructor for this class." The compiler will stop generating the implicit default constructor entirely. When you instantiate A a;, the compiler emits a call to A::A(), but since you never provided a definition (body) for this constructor, the linker can't find it—hence the "undefined reference" error.

Why Does A(); Get Supported by C++ If It Causes Errors? #

C++ follows the philosophy of "trust the programmer"—declaring a function without defining it is perfectly legal, as long as you never call it. For example, if you have struct A { int a; A(); }; in your code but never instantiate A or call its constructor, the compiler and linker won't complain at all. This syntax exists to enable core C++ features like separate compilation and encapsulation, which we'll cover next.

Practical Use Cases for A(); (Declaration Without Definition) #

Here are the most common scenarios where this pattern is useful:

• Separation of Interface and Implementation: This is the classic use case. You declare the constructor in a header file (exposing the class interface) and define it in a separate source file (hiding implementation details):

  // a.h (interface)
  struct A {
      int a;
      A(); // Declaration only
  };
  
  // a.cpp (implementation)
  A::A() : a(42) { // Custom initialization logic
      // Additional setup code goes here
  }
  

  This keeps your header files clean, enforces encapsulation, and makes it easier to modify the implementation without rebuilding all code that includes the header.
• Legacy Way to Prevent Instantiation: Before C++11 introduced = delete, developers would declare a constructor (often private) without defining it to prevent anyone from instantiating a class. For example:

  struct NonInstantiable {
  private:
      NonInstantiable(); // No definition provided
  };
  

  Any attempt to create an instance of NonInstantiable would result in a linker error. (Note: Modern C++ prefers NonInstantiable() = delete; for this, as it catches the error at compile time instead of link time.)
• Conditional or Template-Based Definitions: In template code or conditional compilation scenarios, you might declare a constructor first, then provide different definitions based on template parameters or compile-time flags. For example, a template class might have a constructor that's only defined for certain type arguments, with the declaration in the header and definitions in specialized template implementations.

内容的提问来源于stack exchange，提问作者Joseph D.