What 's the scope of the " using " declaration in C++?

In C++, the "using" declaration is primarily used for two purposes: simplifying access to types or functions within a namespace, and defining type aliases. Regarding scope, we can discuss these two cases separately.

1. Namespace access for types or functions:

Using the "using" declaration, we can introduce specific names from a namespace into the current scope, allowing us to omit the namespace prefix. For example:

cpp
namespace MyNamespace {
    void myFunction() {
        // function implementation
    }
}

int main() {
    using MyNamespace::myFunction;
    myFunction(); // Direct call without the MyNamespace:: prefix
    return 0;
}

In this example, myFunction is introduced into the local scope of the main function. This means within the main function's scope, we can directly use myFunction without the MyNamespace:: prefix.

1. Type aliases:

The "using" declaration can also be used to create type aliases, which is similar to "typedef" but with clearer syntax. The scope of a type alias is determined by the scope where it is defined. For example:

cpp
using Integer = int;

void myFunction() {
    Integer a = 5; // Using the alias Integer instead of int
}

In this example, Integer serves as an alias for int and is valid throughout the program because it is defined in the global scope.

In summary, the scope of names or aliases introduced by "using" declarations depends on where they are declared. If "using" is declared within a function, the name is only valid within that function; if declared in the global scope, it is valid throughout the file (or more broadly, within the same namespace).