Logo
Back

What is the difference between a definition and a declaration in C++?

In C++, declarations and definitions are two fundamental concepts that describe how names (variables, functions, classes, etc.) are introduced and set up in a program.

  1. Declaration: Tells the compiler about the name and type of an entity (function, variable, class, etc.) but does not necessarily allocate storage or provide implementation details.
  2. Definition: Provides the complete details—such as memory allocation for variables or the function body implementation. Definitions make the entity “real” in the program.

Below are some common examples illustrating the difference:

1. Variable Declarations vs. Definitions

Declaration Only

extern int globalVar;  // Declares a global variable but doesn't define it
  • The keyword extern indicates that the variable exists in another translation unit (i.e., another .cpp file). No storage space is allocated at this point.

Definition

int globalVar = 42;    // Defines (and also declares) a global variable
  • This line both declares and allocates storage for globalVar. If another file includes an extern int globalVar; line, it will link to this definition at compile/link time.

2. Function Declarations vs. Definitions

Declaration (Prototype)

int add(int a, int b); // Tells the compiler "there's a function add with this signature"
  • No implementation details are provided, only the function’s interface.
  • Often placed in a header file so other source files know how to call the function.

Definition (Implementation)

int add(int a, int b) {  // Now we provide the body
    return a + b;
}
  • This is where you give the actual code. The function’s behavior is fully specified here, and memory is reserved as needed for the function’s instructions.
  • Typically placed in a .cpp file so that each function has a single definition.

3. Class/Struct Declarations vs. Definitions

Declaration (Class Forward Declaration)

class MyClass; // Just a forward declaration: we don't know the members yet
  • The compiler knows that MyClass is a type, but cannot use its members or size.
  • Useful when you only need pointers or references to MyClass but don’t need its full definition yet.

Definition (Complete Class Definition)

class MyClass {
public:
    MyClass();
    void doSomething();
private:
    int value_;
};
  • Here you specify all details about the class: members, methods, access specifiers, etc.
  • The compiler can allocate objects of this class because it knows the complete layout.

4. Why the Distinction Matters

  1. Separate Compilation
    C++ uses header files (often containing declarations) and source files (often containing definitions) to let the compiler and linker handle code in smaller chunks. Each .cpp can be compiled into an object file independently, and the linker resolves references between definitions and declarations.

  2. Memory Allocation
    A definition typically involves allocating storage or providing an implementation. A declaration states the existence or interface but does not allocate resources by itself.

  3. Avoiding Multiple Definitions
    You can (and often do) declare the same entity multiple times (e.g., in many .cpp files via a shared header), but you must only define it once. Multiple definitions lead to linker errors (e.g., “multiple definition of foo”).

  4. Forward Declarations
    Using a forward declaration can improve compile times and reduce header dependencies, but you cannot instantiate objects of a forward-declared class or access its members until the class is fully defined.

5. Common Pitfalls

  1. Forgetting to Define a Function
    • You declare a function in a header but never implement it in any .cpp file. This leads to a linker error (unresolved external symbol).
  2. Multiple Definitions of the Same Entity
    • If you define the same global variable or function in more than one .cpp file, you’ll get a multiple-definition error during linking.
  3. Mixing Up extern and Definitions
    • Using extern alone doesn’t define the variable. You still need a separate definition somewhere in the codebase.

Why This Matters in Coding Interviews

  • Fundamental to C++ Compilation
    Understanding declarations vs. definitions is crucial for writing large-scale applications that compile quickly and link correctly.
  • Team Collaboration
    In multi-developer projects, dividing code between headers (declarations) and source files (definitions) is a standard practice.
  • Memory Management & Linking
    Grasping how memory is allocated and how the linker resolves symbols showcases thorough knowledge of low-level C++ details—often valuable in systems or embedded programming roles.

Further Resources

For more on C++ best practices and coding interview prep, consider these courses by DesignGurus.io:

  1. Grokking the Coding Interview: Patterns for Coding Questions

    • Learn about patterns that help solve common interview problems efficiently.

  2. Grokking Data Structures & Algorithms for Coding Interviews

    • Build a strong foundation in DS/Algo knowledge essential for top-tier companies.

You can also explore the DesignGurus YouTube Channel for free system design and coding tutorials or book a Mock Interview Session with ex-FAANG engineers to get real-time feedback.

Key Takeaway

  • Declaration: Introduces the name and type/signature of an entity (function, variable, class) to the compiler, but does not allocate storage or provide implementation details.
  • Definition: Provides the full details or implementation, reserving memory or specifying the function body, making the entity usable and linkable within the program.
CONTRIBUTOR
TechGrind