Dominando Namespaces em C++: Evite Conflitos de Funções

Considere uma situação onde temos duas pessoas com o mesmo nome, Zara, na mesma turma. Sempre que precisarmos diferenciá-las, definitivamente teremos que usar alguma informação adicional junto com o nome, como a área onde moram, ou o nome da mãe ou pai, etc.

A mesma situação pode surgir em suas aplicações C++. Por exemplo, você pode estar escrevendo código que tem uma função chamada xyz() e há outra biblioteca disponível que também tem a mesma função xyz(). Agora o compilador não tem como saber qual versão da função xyz() você está referenciando no seu código.

Um namespace é projetado para superar esta dificuldade e é usado como informação adicional para diferenciar funções, classes, variáveis etc. semelhantes com o mesmo nome disponíveis em diferentes bibliotecas. Usando namespace, você pode definir o contexto em que nomes são definidos. Em essência, um namespace define um escopo.

Definindo um Namespace

Uma definição de namespace começa com a palavra-chave namespace seguida pelo nome do namespace da seguinte forma:

namespace namespace_name {
    // declarações de código
}

Para chamar a versão namespace-enabled de uma função ou variável, faça prefixo (::) com o nome do namespace da seguinte forma:

name::code; // code pode ser variável ou função

Vamos ver como o escopo do namespace abrange entidades incluindo variáveis e funções:

#include <iostream>
using namespace std;
// primeiro namespace
namespace first_space {
    void func() {
        cout << "Inside first_space" << endl;
    }
}
// segundo namespace
namespace second_space {
    void func() {
        cout << "Inside second_space" << endl;
    }
}
int main() {
    // Chama função do primeiro namespace
    first_space::func();
    // Chama função do segundo namespace
    second_space::func();
    return 0;
}

Se compilarmos e executarmos o código acima, isso produziria o seguinte resultado:

Inside first_space
Inside second_space

A Diretiva using

Você também pode evitar o prefixo de namespaces com a diretiva using namespace. Esta diretiva diz ao compilador que o código subsequente está fazendo uso de nomes no namespace especificado. O namespace é assim implícito para o código seguinte:

#include <iostream>
using namespace std;
// primeiro namespace
namespace first_space {
    void func() {
        cout << "Inside first_space" << endl;
    }
}
// segundo namespace
namespace second_space {
    void func() {
        cout << "Inside second_space" << endl;
    }
}
using namespace first_space;
int main() {
    // Isto chama função do primeiro namespace
    func();
    return 0;
}

Se compilarmos e executarmos o código acima, isso produziria o seguinte resultado:

Inside first_space

A diretiva 'using' também pode ser usada para referenciar um item particular dentro de um namespace. Por exemplo, se a única parte do namespace std que você pretende usar é cout, você pode referenciá-la da seguinte forma:

using std::cout;

Código subsequente pode referenciar cout sem prefixar o namespace, mas outros itens no namespace std ainda precisarão ser explícitos:

#include <iostream>
using std::cout;
int main() {
    cout << "std::endl is used with std!" << std::endl;
    return 0;
}

Se compilarmos e executarmos o código acima, isso produziria o seguinte resultado:

std::endl is used with std!

Nomes introduzidos em uma diretiva using obedecem regras normais de escopo. O nome é visível a partir do ponto da diretiva using até o fim do escopo em que a diretiva é encontrada. Entidades com o mesmo nome definidas em um escopo externo são ocultadas.

Namespaces Discontíguos

Um namespace pode ser definido em várias partes e assim um namespace é composto pela soma de suas partes definidas separadamente. As partes separadas de um namespace podem ser espalhadas por múltiplos arquivos.

Então, se uma parte do namespace requer um nome definido em outro arquivo, esse nome ainda deve ser declarado. Escrever uma definição de namespace a seguir define um novo namespace ou adiciona novos elementos a um existente:

namespace namespace_name {
    // declarações de código
}

Namespaces Aninhados

Namespaces podem ser aninhados onde você pode definir um namespace dentro de outro namespace da seguinte forma:

namespace namespace_name1 {
    // declarações de código
    namespace namespace_name2 {
        // declarações de código
    }
}

Você pode acessar membros de namespace aninhado usando operadores de resolução da seguinte forma:

// para acessar membros de namespace_name2
using namespace namespace_name1::namespace_name2;
// para acessar membros de namespace_name1
using namespace namespace_name1;

Nas instruções acima, se você estiver usando namespace_name1, isso tornará elementos de namespace_name2 disponíveis no escopo da seguinte forma:

#include <iostream>
using namespace std;
// primeiro namespace
namespace first_space {
    void func() {
        cout << "Inside first_space" << endl;
    }
    // segundo namespace
    namespace second_space {
        void func() {
            cout << "Inside second_space" << endl;
        }
    }
}
using namespace first_space::second_space;
int main() {
    // Isto chama função do segundo namespace
    func();
    return 0;
}

Se compilarmos e executarmos o código acima, isso produziria o seguinte resultado:

Inside second_space