Última atualização：2026-10-12

Declarações e aliases com using em C++¶

Sobre o autor:¶

Conta oficial do WeChat:

wechat

Uso básico¶

Using local e global; as operações concretas e o uso estão nos exemplos a seguir:

#include <iostream>
#define isNs1 1
//#define isGlobal 2
using namespace std;
void func() 
{
    cout<<"::func"<<endl;
}

namespace ns1 {
    void func()
    {
        cout<<"ns1::func"<<endl; 
    }
}

namespace ns2 {
#ifdef isNs1 
    using ns1::func;    /// ns1中的函数
#elif isGlobal
    using ::func; /// 全局中的函数
#else
    void func() 
    {
        cout<<"other::func"<<endl; 
    }
#endif
}

int main() 
{
    /**
     * 这就是为什么在c++中使用了cmath而不是math.h头文件
     */
    ns2::func(); // 会根据当前环境定义宏的不同来调用不同命名空间下的func()函数
    return 0;
}

O código completo está em: using_global.cpp

Alterando a acessibilidade¶

class Base{
public:
 std::size_t size() const { return n;  }
protected:
 std::size_t n;
};
class Derived : private Base {
public:
 using Base::size;
protected:
 using Base::n;
};

A classe Derived herda Base de forma privada, de modo que, para ela, a variável membro n e a função membro size são privadas; com o uso da instrução using, é possível alterar a acessibilidade delas — como no exemplo acima, size passa a ser acessível com permissão public e n com permissão protected. O código completo está em: derived_base.cpp

Sobrecarga de funções¶

No processo de herança, a classe derivada pode ocultar zero ou mais instâncias de funções sobrecarregadas; assim que uma versão sobrecarregada é definida, as demais versões sobrecarregadas ficam invisíveis.

Se, para as funções sobrecarregadas da classe base, precisarmos modificar uma na classe derivada e ainda assim manter as demais visíveis, é preciso sobrecarregar todas as versões — algo muito trabalhoso.

#include <iostream>
using namespace std;

class Base{
    public:
        void f(){ cout<<"f()"<<endl;
        }
        void f(int n){
            cout<<"Base::f(int)"<<endl;
        }
};

class Derived : private Base {
    public:
        using Base::f;
        void f(int n){
            cout<<"Derived::f(int)"<<endl;
        }
};

int main()
{
    Base b;
    Derived d;
    d.f();
    d.f(1);
    return 0;
}

Como no código acima, ao usar na classe derivada uma instrução de declaração using especificando apenas um nome, sem lista de parâmetros formais, uma única declaração using da função membro da classe base adiciona ao escopo da classe derivada todas as instâncias sobrecarregadas dessa função. Nesse caso, a classe derivada só precisa definir as funções que lhe são específicas, sem redefinir as demais funções herdadas.

O código completo está em: using_derived.cpp

Substituindo o typedef¶

Em C, é comum usar a sintaxe typedef A B, que define B como o tipo A, ou seja, dá ao tipo A o alias B.

Correspondendo a typedef A B, usar using B=A realiza a mesma operação.

typedef vector<int> V1; 
using V2 = vector<int>;

O código completo está em: using_typedef.cpp