Última actualización：2026-10-12

Declaraciones using y alias en C++¶

Sobre el autor:¶

Cuenta pública personal:

wechat

Uso básico¶

using local y global; las operaciones y usos concretos se muestran en los siguientes ejemplos:

#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;
}

El código completo puede verse en: using_global.cpp

Cambiar la accesibilidad¶

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;
};

La clase Derived hereda de Base de forma privada, de modo que para ella la variable miembro n y la función miembro size son privadas; si se usa una sentencia using, se puede cambiar su accesibilidad: como en el ejemplo anterior, a size se puede acceder con permisos public, y a n con permisos protected. El código completo puede verse en: derived_base.cpp

Sobrecarga de funciones¶

Durante la herencia, la clase derivada puede cubrir cero o más instancias de las funciones sobrecargadas; en cuanto se define una versión sobrecargada, las demás versiones sobrecargadas se vuelven invisibles.

Si, de las funciones sobrecargadas de la clase base, necesitamos modificar una en la clase derivada y mantener visibles las demás, hay que sobrecargar todas las versiones, lo cual resulta muy tedioso.

#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;
}

En el código anterior, en la clase derivada se usa una sentencia de declaración using especificando un nombre sin lista de parámetros formales; de este modo, una sola declaración using de una función miembro de la clase base añade al ámbito de la clase derivada todas las instancias sobrecargadas de esa función. En este punto, la clase derivada solo necesita definir sus funciones propias, sin tener que redefinir las demás funciones heredadas.

El código completo puede verse en: using_derived.cpp

Sustituir a typedef¶

En C es habitual la sintaxis typedef A B, que define B como el tipo A, es decir, le da al tipo A el alias B

Correspondiendo a typedef A B, se puede usar using B=A para realizar la misma operación.

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

El código completo puede verse en: using_typedef.cpp