Lære Anonymous and Inline Namespaces

Anonymous namespaces provide a way to give internal linkage to identifiers, meaning that anything declared inside an anonymous namespace is only visible within the same translation unit (usually a single source file). This technique is commonly used to restrict the scope of functions, variables, or classes so they do not conflict with similarly named entities in other files. By wrapping declarations in an anonymous namespace, you ensure that they cannot be accessed from other translation units, helping to prevent name collisions and unintended linkage.

main.cpp


              1234567891011121314
            
#include <iostream>

// Function with internal linkage due to anonymous namespace
namespace {
    void printInternal() { std::cout << "Hello from the anonymous namespace!" << std::endl; }
}

void printExternal() { std::cout << "Hello from outside the anonymous namespace!" << std::endl; }

int main()
{
    printInternal();   // Accessible here
    printExternal();   // Also accessible here
}

Building on this idea of namespace-based organization, C++ also provides inline namespaces. Inline namespaces are especially useful for versioning APIs, allowing you to group different versions of functions or classes under a single namespace. When you declare a namespace as inline, its contents are automatically made available as if they were part of the enclosing namespace, making it easy to provide default versions while still supporting explicit version selection. This approach is frequently used in library design to manage backward compatibility and smooth transitions between API versions.

main.cpp


              1234567891011121314151617
            
#include <iostream>

namespace API {
    inline namespace v1 {
        void greet() { std::cout << "Hello from API version 1!" << std::endl; }
    }
    
    namespace v2 {
        void greet() { std::cout << "Hello from API version 2!" << std::endl; }
    }
}

int main()
{
    API::greet();      // Calls v1::greet() by default due to inline namespace
    API::v2::greet();  // Explicitly calls v2::greet()
}

Anonymous namespaces are primarily used to restrict the visibility of identifiers to a single translation unit, making them ideal for internal implementation details that should not be accessible elsewhere. Inline namespaces, on the other hand, are designed for versioning and API management, allowing you to offer multiple versions of an interface while providing a default version that is easily accessible. Both features help you organize code more effectively and avoid naming conflicts, but they serve different practical purposes within C++ programming.

Var alt klart?

Tak for dine kommentarer!

Sektion 2. Kapitel 3

Spørg AI

Spørg om hvad som helst eller prøv et af de foreslåede spørgsmål for at starte vores chat

Awesome!

Completion rate improved to 12.5

Stryg for at vise menuen

main.cpp


              1234567891011121314
            
#include <iostream>

// Function with internal linkage due to anonymous namespace
namespace {
    void printInternal() { std::cout << "Hello from the anonymous namespace!" << std::endl; }
}

void printExternal() { std::cout << "Hello from outside the anonymous namespace!" << std::endl; }

int main()
{
    printInternal();   // Accessible here
    printExternal();   // Also accessible here
}

main.cpp


              1234567891011121314151617
            
#include <iostream>

namespace API {
    inline namespace v1 {
        void greet() { std::cout << "Hello from API version 1!" << std::endl; }
    }
    
    namespace v2 {
        void greet() { std::cout << "Hello from API version 2!" << std::endl; }
    }
}

int main()
{
    API::greet();      // Calls v1::greet() by default due to inline namespace
    API::v2::greet();  // Explicitly calls v2::greet()
}

Var alt klart?

Tak for dine kommentarer!

Sektion 2. Kapitel 3