Alias
Il est possible d'utiliser une déclaration d'alias pour déclarer un nom à utiliser comme un synonyme d'un type déclaré précédemment. (ce mécanisme est informellement appellé alias de type). Il est possible également d'utiliser ce mécanisme pour créer un modèle d'alias, qui peut être particulièrement utile pour les allocateurs personnalisés.
using identifier = type;
Notes
identifier
Nom de l'alias.type
L'identificateur de type pour lequel vous créez un alias.
Un alias n'introduit pas de nouveau type et ne peut pas modifier la signification du nom d'un type existant.
La forme la plus simple d'un alias équivaut au mécanisme typedef de C++03 :
// C++11
using counter = long;
// C++03 equivalent:
// typedef long counter;
Tous deux permettent de créer des variables de type « compteur ». Quelque chose plus utile est un type alias comme celui-ci pour 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);
Les alias fonctionnent également avec des pointeurs fonction, mais beaucoup plus lisibles que l'équivalent dans 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;
Une limitation du mécanisme typedef est que cela ne fonctionne pas avec les modèles. Toutefois, la syntaxe de type alias dans C++11 permet la création de modèles d'alias :
template<typename T> using ptr = T*;
// the name 'ptr<T>' is now an alias for pointer to T
ptr<int> ptr_int;
Exemple
L'exemple suivant montre comment utiliser un modèle d'alias à un allocateur- dans ce cas, un type de vecteur d'entiers. Il est possible de remplacer tout type par int pour créer un alias pratique pour masquer des listes de paramètres complexes dans votre code fonctionnel principal. En utilisant l'allocateur personnalisé à travers votre code il est possible d'améliorer la lisibilité et réduire le risque d'introduire des bogues provoqués par des typos.
#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;
}