Карта сайта Kansoftware
НОВОСТИУСЛУГИРЕШЕНИЯКОНТАКТЫ
Разработка программного обеспечения

Boost.Hana: boost::hana::type< T > Struct Template Reference

Boost , ,

Boost.Hana  1.0.1
Your standard library for metaprogramming
C++ тип в представлении на уровне стоимости.

type - это особый вид объекта, представляющий тип C++, такой как int, void, std::vector или что-либо еще, что вы можете себе представить.

Эта страница объясняет, как тип работает на низком уровне. Чтобы получить интуицию о метапрограммировании уровня типа в Хане, вы должны прочитать раздел tutorial на вычислениях уровня типа.

Note
For subtle reasons having to do with ADL, the actual representation of hana::type is implementation-defined. In particular, hana::type may be a dependent type, so one should not attempt to do pattern matching on it. However, one can assume that hana::type inherits from hana::basic_type, which can be useful when declaring overloaded functions:
template <typename T>
void f(hana::basic_type<T>) {
// do something with T
}

Lvalues and rvalues

При хранении type в гетерогенных контейнерах некоторые алгоритмы возвращают ссылки на эти объекты. Поскольку мы в первую очередь заинтересованы в доступе к их вложенному ::type, получение ссылки нежелательно; мы в конечном итоге пытаемся получить вложенное ::type внутри эталонного типа, который является ошибкой компиляции:

auto ts = make_tuple(type_c<int>, type_c<char>);
using T = decltype(ts[0_c])::type; // error: 'ts[0_c]' is a reference!

По этой причине types обеспечивают перегрузку оператора unary +, который может быть использован для превращения значения l в r value. Таким образом, при использовании результата, который может быть ссылкой на объект type, можно использовать +, чтобы убедиться, что r value получен до получения его вложенного ::type:

auto ts = make_tuple(type_c<int>, type_c<char>);
using T = decltype(+ts[0_c])::type; // ok: '+ts[0_c]' is an rvalue

Modeled concepts

  1. Comparable
    Два типа равны тогда и только тогда, когда они представляют один и тот же тип C++. Следовательно, равенство эквивалентно признаку типаstd::is_same.
    // Авторское право Louis Dionne 2013-2016
    // Распространяется под лицензией Boost Software License, версия 1.0.
    // (См. сопроводительный файл LICENSE.md или копию на http://boost.org/LICENSE_1_0.txt)
    пространство именхана =повышение::хана;
    структураТ;
    структураU;
    BOOST_HANA_CONSTANT_CHECK(hana::type_c== hana::type_c);
    BOOST_HANA_CONSTANT_CHECK(hana::type_c!= hana::type_c;
    intmain()
    [ORIG_END] -->
  2. Hashable
    Хэш типа — это сам тип. Другими словами,hashявляется функцией идентификации наhana::typeс.
    // Авторское право Louis Dionne 2013-2016
    // Распространяется по лицензии Boost Software License, версия 1.0.
    // (См. сопроводительный файл LICENSE.md или копия по адресу http://boost.org/LICENSE_1_0.txt)
    #include<
    // 'hana:
    [ [ORIG_END] -->

Synopsis of associated functions

template<typename T >
constexpr type< T > type_c {}
 Creates an object representing the C++ type T. More...
 
constexpr auto decltype_ = see documentation
 decltype keyword, lifted to Hana. More...
 
constexpr auto typeid_ = see documentation
 Returns a hana::type representing the type of a given object. More...
 
template<>
constexpr auto make< type_tag > = hana::decltype_
 Equivalent to decltype_, provided for convenience. More...
 
constexpr auto make_type = hana::make<type_tag>
 Equivalent to make<type_tag>, provided for convenience. More...
 
constexpr auto sizeof_
 sizeof keyword, lifted to Hana. More...
 
constexpr auto alignof_
 alignof keyword, lifted to Hana. More...
 
constexpr auto is_valid
 Checks whether a SFINAE-friendly expression is valid. More...
 

Friends

template<typename X , typename Y >
constexpr auto operator== (X &&x, Y &&y)
 Equivalent to hana::equal
 
template<typename X , typename Y >
constexpr auto operator!= (X &&x, Y &&y)
 Equivalent to hana::not_equal
 

Public Member Functions

constexpr auto operator+ () const
 Returns rvalue of self. See description.
 

Associated functions

template<typename T >
template<typename T >
constexpr type<T> type_c {}
related

Создает объект, представляющий тип C++ T.

template<typename T >
constexpr auto decltype_ = see documentation
related

деклотип ключевое слово, снятое на Хану.

Deprecated:
The semantics of decltype_ are can be confusing, and hana::typeid_ should be preferred instead. decltype_ may be removed in the next major version of the library.

деклотип_ несколько эквивалентен деклотипу в том, что он возвращает тип объекта, за исключением того, что он возвращает его как хана::type, который является первоклассным гражданином Ханы вместо сырого типа C++. В частности, учитывая объект x, деклотип_

decltype_(x) == type_c<decltype(x) with references stripped>

Как вы можете видеть, деклтип_ отключит любую ссылку от фактического типа объекта. Причина этого объясняется ниже. Однако любые cv-квалификаторы будут сохранены. Кроме того, при наличии hana::type, decltype_ является просто функцией идентификации. Следовательно, для любого типа C++ T,

decltype_(type_c<T>) == type_c<T>

В сочетании с уточнением метафункция и аль. это поведение облегчает взаимодействие с обоими типами и значениями одновременно. Однако это делает невозможным создание type, содержащего другой type с decltype_. Другими словами, невозможно создать type_c)> с этой утилитой, потому что decltype_(type_c) будет просто type_c вместо type_c)>. Предполагается, что этот случай использования является редким, и функция, закодированная вручную, может быть использована, если это необходимо.

Rationale for stripping the references

Правила для вывода аргументов шаблона таковы, что идеальное решение, которое всегда соответствует деклтипу, невозможно. Следовательно, мы должны найти решение, которое является хорошим и достаточно последовательным для наших потребностей. Один из случаев, когда сопоставление поведения деклотипа невозможно, - это когда аргумент является простой, непрозрачной переменной или параметром функции. В этом случае аргумент деклотипа_ будет выведен в качестве ссылки на эту переменную, но деклотип дал бы нам фактический тип этой переменной без ссылок. Кроме того, с учетом нынешнего определения метафункция & al., было бы в основном бесполезно, если бы деклотип_ может вернуть ссылку, потому что маловероятно, что F ожидает ссылку в своем простейшем случае использования:

int i = 0;
auto result = metafunction<F>(i);

Следовательно, всегда отказ от ссылок кажется наименее болезненным решением.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
namespace hana = boost::hana;
struct X { };
BOOST_HANA_CONSTANT_CHECK(hana::decltype_(X{}) == hana::type_c<X>);
BOOST_HANA_CONSTANT_CHECK(hana::decltype_(hana::type_c<X>) == hana::type_c<X>);
BOOST_HANA_CONSTANT_CHECK(hana::decltype_(1) == hana::type_c<int>);
static int const& i = 1;
BOOST_HANA_CONSTANT_CHECK(hana::decltype_(i) == hana::type_c<int const>);
int main() { }
template<typename T >
constexpr auto typeid_ = see documentation
related

Description.

хана::typeid_ несколько похож на typeid, поскольку он возвращает то, что представляет тип объекта. Однако то, что возвращает typeid, представляет тип объекта runtime, а hana::typeid_ возвращает тип объекта static. В частности, учитывая объект x, typeid_ удовлетворяет

typeid_(x) == type_c<decltype(x) with ref and cv-qualifiers stripped>

Как вы можете видеть, typeid_ снимает любую ссылку и кв-квалификатор из фактического типа объекта. Причина этого заключается в том, что он точно моделирует, как язык typeid ведет себя в отношении ссылок и клавиатур, и это также является желательным поведением большую часть времени. Кроме того, когда дается хана::type, typeid_ - это просто функция идентификации. Следовательно, для любого типа C++ T,

typeid_(type_c<T>) == type_c<T>

В сочетании с уточнением метафункция & al. это поведение облегчает взаимодействие с обоими типами и значениями одновременно. Тем не менее, это делает невозможным создание type, содержащего другой type с использованием typeid_. Предполагается, что этот случай использования является редким, и функция, закодированная вручную, может быть использована, если это необходимо.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <string>
namespace hana = boost::hana;
struct Cat { std::string name; };
struct Dog { std::string name; };
struct Fish { std::string name; };
bool operator==(Cat const& a, Cat const& b) { return a.name == b.name; }
bool operator!=(Cat const& a, Cat const& b) { return a.name != b.name; }
bool operator==(Dog const& a, Dog const& b) { return a.name == b.name; }
bool operator!=(Dog const& a, Dog const& b) { return a.name != b.name; }
bool operator==(Fish const& a, Fish const& b) { return a.name == b.name; }
bool operator!=(Fish const& a, Fish const& b) { return a.name != b.name; }
int main() {
hana::tuple<Cat, Fish, Dog, Fish> animals{
Cat{"Garfield"}, Fish{"Jaws"}, Dog{"Beethoven"}, Fish{"Nemo"}
};
auto mammals = hana::remove_if(animals, [](auto const& a) {
return hana::typeid_(a) == hana::type<Fish>{};
});
BOOST_HANA_RUNTIME_CHECK(mammals == hana::make_tuple(Cat{"Garfield"}, Dog{"Beethoven"}));
}
template<typename T >
template<>
constexpr auto make< type_tag > = hana::decltype_
related

Эквивалент деклотип_, предоставляется для удобства.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
namespace hana = boost::hana;
struct X { };
BOOST_HANA_CONSTANT_CHECK(hana::make<hana::type_tag>(X{}) == hana::type_c<X>);
BOOST_HANA_CONSTANT_CHECK(hana::make<hana::type_tag>(hana::type_c<X>) == hana::type_c<X>);
BOOST_HANA_CONSTANT_CHECK(hana::make_type(X{}) == hana::type_c<X>);
BOOST_HANA_CONSTANT_CHECK(hana::make_type(hana::type_c<X>) == hana::type_c<X>);
int main() { }
template<typename T >
constexpr auto make_type = hana::make<type_tag>
related

Эквивалент make<type_tag>, предусмотрен для удобства.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
namespace hana = boost::hana;
struct X { };
BOOST_HANA_CONSTANT_CHECK(hana::make<hana::type_tag>(X{}) == hana::type_c<X>);
BOOST_HANA_CONSTANT_CHECK(hana::make<hana::type_tag>(hana::type_c<X>) == hana::type_c<X>);
BOOST_HANA_CONSTANT_CHECK(hana::make_type(X{}) == hana::type_c<X>);
BOOST_HANA_CONSTANT_CHECK(hana::make_type(hana::type_c<X>) == hana::type_c<X>);
int main() { }
template<typename T >
constexpr auto sizeof_
related
Initial value:
= [](auto&& x) {
using T = typename decltype(hana::decltype_(x))::type;
return hana::size_c<sizeof(T)>;
}

размер ключевое слово, снятое на Хану.

размер_ несколько эквивалентен размер, поскольку он возвращает размер выражения или типа, но он принимает произвольное выражение или хана::type и возвращает его размер как integral_constant. В частности, с учетом выражения expr, размер_ удовлетворяет

sizeof_(expr) == size_t<sizeof(decltype(expr) with references stripped)>

Однако, учитывая тип, размер_, просто будет иметь размер типа C++, представленного этим объектом. Другими словами,

sizeof_(type_c<T>) == size_t<sizeof(T)>

Поведение размер_ согласуется с поведением деклтипа_. В частности, см. документацию деклотипа_, чтобы понять, почему ссылки всегда отрезаются размером_.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
namespace hana = boost::hana;
struct X { };
static_assert(hana::sizeof_(hana::type_c<X>) == sizeof(X), "");
static_assert(hana::sizeof_(1) == sizeof(1), "");
static_assert(hana::sizeof_(hana::type_c<int>) == sizeof(int), "");
int main() {}
template<typename T >
constexpr auto alignof_
related
Initial value:
= [](auto&& x) {
using T = typename decltype(hana::decltype_(x))::type;
return hana::size_c<alignof(T)>;
}

ино ключевое слово, снятое на Хану.

alignof_ несколько эквивалентен alignof в том, что он возвращает выравнивание, требуемое любым экземпляром типа, но он принимает type и возвращает его выравнивание как integral_constant. В частности, с учетом выражения expr и C++ типа T, alignof_ удовлетворяет

alignof_(expr) == size_t<alignof(decltype(expr) with references stripped)>
alignof_(type_c<T>) == size_t<alignof(T)>

Поведение alignof_ согласуется с поведением decltype_. В частности, см. документацию decltype_, чтобы понять, почему ссылки всегда разорваны alignof_.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
namespace hana = boost::hana;
struct X { };
static_assert(hana::alignof_(hana::type_c<X>) == alignof(X), "");
static_assert(hana::alignof_(1) == alignof(decltype(1)), "");
static_assert(hana::alignof_(hana::type_c<int>) == alignof(int), "");
int main() { }
template<typename T >
constexpr auto is_valid
related
Initial value:
= [](auto&& f) {
return [](auto&& ...args) {
return whether f(args...) is a valid expression;
};
}

Проверяет, является ли выражение SFINAE действительным.

Учитывая SFINAE-дружественную функцию, is_valid возвращает, действительно ли функциональный вызов с заданными аргументами. В частности, учитывая функцию f и аргументы args...,

is_valid(f, args...) == whether f(args...) is valid

Результат возвращается как компиляционное время Logical. Кроме того, is_valid может использоваться в карриированной форме следующим образом:

is_valid(f)(args...)

Этот синтаксис позволяет легко создавать функции, которые проверяют действительность общего выражения на любом заданном аргументе(ах).

Warning
To check whether calling a nullary function f is valid, one should use the is_valid(f)() syntax. Indeed, is_valid(f /* no args */) will be interpreted as the currying of is_valid to f rather than the application of is_valid to f and no arguments.

Example

// Copyright Louis Dionne 2013-2016
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <string>
#include <vector>
namespace hana = boost::hana;
int main() {
// Checking for a member
struct Person { std::string name; };
auto has_name = hana::is_valid([](auto&& p) -> decltype((void)p.name) { });
Person joe{"Joe"};
static_assert(has_name(joe), "");
static_assert(!has_name(1), "");
// Checking for a nested type
auto has_value_type = hana::is_valid([](auto t) -> hana::type<
typename decltype(t)::type::value_type
> { });
static_assert(has_value_type(hana::type_c<std::vector<int>>), "");
static_assert(!has_value_type(hana::type_c<Person>), "");
}

Статья Boost.Hana: boost::hana::type< T > Struct Template Reference раздела может быть полезна для разработчиков на c++ и boost.




Материалы статей собраны из открытых источников, владелец сайта не претендует на авторство. Там где авторство установить не удалось, материал подаётся без имени автора. В случае если Вы считаете, что Ваши права нарушены, пожалуйста, свяжитесь с владельцем сайта.



:: Главная :: ::


реклама


©KANSoftWare (разработка программного обеспечения, создание программ, создание интерактивных сайтов), 2007
Top.Mail.Ru

Время компиляции файла: 2024-08-30 11:47:00
2025-05-20 05:16:12/0.0089089870452881/1