Alias
Se puede utilizar una declaración de alias para declarar un nombre que se usará como sinónimo para un tipo declarado previamente. (Este mecanismo también se conoce informalmente como alias de tipo). También se puede utilizar este mecanismo para crear una plantilla de alias, que puede resultar especialmente útil para los asignadores personalizados.
using identifier = type;
Comentarios
identifier
Nombre del alias.type
Identificador de tipo para el que se va a crear un alias.
Un alias no presenta un tipo nuevo y no puede cambiar el significado de un nombre de tipo existente.
El formato más sencillo de alias es equivalente al mecanismo typedef de C++03:
// C++11
using counter = long;
// C++03 equivalent:
// typedef long counter;
Ambos permiten la creación de variables de tipo "contador". Algo más útil sería un alias de tipo como este para std::ios_base::fmtflags:
// C++11
using fmtfl = std::ios_base::fmtflags;
// C++03 equivalent:
// typedef std::ios_base::fmtflags fmtfl;
fmtfl fl_orig = std::cout.flags();
fmtfl fl_hex = (fl_orig & ~std::cout.basefield) | std::cout.showbase | std::cout.hex;
// ...
std::cout.flags(fl_hex);
Los alias también funcionan con punteros a función, pero son mucho más legibles que el equivalente de typedef:
// C++11
using func = void(*)(int);
// C++03 equivalent:
// typedef void (*func)(int);
// func can be assigned to a function pointer value
void actual_function(int arg) { /* some code */ }
func fptr = &actual_function;
Una limitación del mecanismo typedef es que no funciona con plantillas. Sin embargo, la sintaxis de alias de tipo de C++11 permite la creación de plantillas de alias:
template<typename T> using ptr = T*;
// the name 'ptr<T>' is now an alias for pointer to T
ptr<int> ptr_int;
Ejemplo
En el ejemplo siguiente se muestra cómo utilizar una plantilla de alias con un asignador personalizado; en este caso, un tipo de vector entero. Puede sustituir cualquier tipo por int para crear un alias adecuado con el fin de ocultar las listas de parámetros complejos en el código funcional principal. El uso del asignador personalizado en todo el código puede mejorar la legibilidad y reducir el riesgo de introducir errores debidos a errores ortográficos.
#include <stdlib.h>
#include <new>
template <typename T> struct MyAlloc {
typedef T value_type;
MyAlloc() { }
template <typename U> MyAlloc(const MyAlloc<U>&) { }
bool operator==(const MyAlloc&) const { return true; }
bool operator!=(const MyAlloc&) const { return false; }
T * allocate(const size_t n) const {
if (n == 0) {
return nullptr;
}
if (n > static_cast<size_t>(-1) / sizeof(T)) {
throw std::bad_array_new_length();
}
void * const pv = malloc(n * sizeof(T));
if (!pv) {
throw std::bad_alloc();
}
return static_cast<T *>(pv);
}
void deallocate(T * const p, size_t) const {
free(p);
}
};
#include <vector>
using MyIntVector = std::vector<int, MyAlloc<int>>;
#include <iostream>
int main ()
{
MyIntVector foov = { 1701, 1764, 1664 };
for (auto a: foov) std::cout << a << " ";
std::cout << "\n";
return 0;
}