In-depth Analysis of g++ "undefined reference to typeinfo" Linker Errors

Error Phenomenon and Background

During C++ development with the g++ compiler, developers often encounter linker errors similar to the following:

(.gnu.linkonce.[stuff]): undefined reference to [method]
[object file]:(.gnu.linkonce.[stuff]): undefined reference to `typeinfo for [classname]`

These errors typically occur during the linking phase, indicating that the compiler cannot find type information for specific classes or methods. Understanding the underlying mechanism is crucial for resolving and preventing such issues.

Core Cause Analysis

The most common cause of "undefined reference to typeinfo" errors is undeclared virtual function definitions. In C++, when a class contains virtual functions, the compiler needs to generate type information (typeinfo) for that class, which supports runtime type identification (RTTI) features.

Consider the following code example:

class MyClass {
public:
    virtual void method();  // Declaration only, no definition
};

In this example, method() is declared as a virtual function but lacks a concrete implementation. The compiler generates type information for MyClass, but since the virtual function is undefined, the linker cannot find the complete type information implementation during final linking.

Solutions and Correct Practices

To resolve this issue, ensure that all non-pure virtual functions have explicit definitions. Here are several correct implementation approaches:

Approach 1: Inline Definition

class MyClass {
public:
    virtual void method() {
        // Concrete function implementation
        std::cout << "Method implementation" << std::endl;
    }
};

Approach 2: External Definition

// Header file declaration
class MyClass {
public:
    virtual void method();
};

// Source file definition
void MyClass::method() {
    // Concrete function implementation
    std::cout << "Method implementation" << std::endl;
}

Approach 3: Pure Virtual Function

If the function doesn't require a concrete implementation, declare it as a pure virtual function:

class MyClass {
public:
    virtual void method() = 0;  // Pure virtual function
};

Analogical Understanding

This situation is analogous to external variable declarations in C++:

extern int external_var;
int* ptr = &external_var;

Here, external_var is declared to exist in another compilation unit, and the linker needs to resolve its address during linking. Similarly, undefined virtual functions require their implementations to be found at link time.

Impact of RTTI Compilation Options

Another potential cause is inconsistent RTTI compilation options. When a project mixes -fno-rtti (disable RTTI) and -frtti (enable RTTI) options, type information mismatches may occur.

For example, if a class's key methods are compiled with RTTI disabled, while other code accessing the class's type information (such as using dynamic_cast or creating objects) has RTTI enabled, linker errors will result. The solution is to ensure consistent RTTI compilation options across all code that accesses type information.

Preventive Measures and Best Practices

To avoid "undefined reference to typeinfo" errors, follow these best practices:

1. Complete Virtual Function Definitions: Ensure all non-pure virtual functions have explicit definitions, whether inline or external.
2. Use Pure Virtual Functions for Clear Intent: For interface methods that don't require implementations, use pure virtual function declarations.
3. Maintain Consistent Compilation Options: Keep RTTI compilation options consistent throughout the project.
4. Regular Compilation Testing: Compile and link regularly during development to identify potential linking issues early.
5. Understand Type Information Mechanisms: Deeply understand C++'s RTTI mechanism and virtual function table workings.

By following these practices, developers can effectively prevent and resolve "undefined reference to typeinfo" linker errors, enhancing code robustness and maintainability.