Aliasy

Článek
06/09/2015

Můžete použít alias prohlášení název, který chcete použít jako synonymum pro dříve deklarovaný typ deklarace. (Tento mechanismus se také nazývá neformálně typu alias).Tento mechanismus lze také použít k vytvoření Šablona alias, což je zvláště užitečné pro vlastní allocators.

using identifier = type;

Poznámky

identifier
Název aliasu.
type
Identifikátor typu vytvářeného alias.

Alias nezavádí nový typ a smyslu existující název typu nelze změnit.

Nejjednodušší forma alias je ekvivalentní typedef mechanismus z 03 C ++:

// C++11
using counter = long;

// C++03 equivalent:
// typedef long counter;

Obě tyto umožňují vytvářet proměnné typu "čítač".Něco užitečnější by bylo typu alias tohoto typu pro 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);

Aliasy také ukazatele na funkci, ale je mnohem čitelnější než ekvivalentní definice typedef je práce:

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

Omezení typedef mechanismus je, že není práce s šablonami.Však syntaxe typu alias v C ++ 11 umožňuje vytváření šablon alias:

template<typename T> using ptr = T*; 

// the name 'ptr<T>' is now an alias for pointer to T
ptr<int> ptr_int;

Příklad

Následující příklad ukazuje, jak použít šablonu alias s vlastním přidělováním – v tomto případě vektorové integer typu.Můžete použít libovolný typ pro int k vytvoření vhodné alias, chcete-li skrýt parametr složité jsou uvedeny v hlavním kódu funkční.Pomocí přidělujícího modulu vlastní prostřednictvím vašeho kódu lze zlepšit čitelnost a snížit nebezpečí zavlečení chyby způsobené překlepy.

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

Výsledek

Viz také

Referenční dokumentace

using – klíčové slovo

Sdílet prostřednictvím