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

Boost.Hana: boost::hana::integral_constant< T, v > Struct Template Reference

Boost , ,

Boost.Hana  1.0.1
Your standard library for metaprogramming
Значение времени компиляции интегрального типа.

<integral_constant>является объектом, представляющим интегральное значение времени компиляции. Как следует из названия,<hana::integral_constant>в основном эквивалентен<std::integral_constant>, за исключением того, что<hana::integral_constant>также предоставляет другие лакомства, чтобы сделать их более простыми в использовании, такие как арифметические операторы и аналогичные функции. В частности,<hana::integral_constant>гарантированно наследуется от соответствующего<std::integral_constant>и, следовательно, имеет одинаковые члены и возможности. Приведенные ниже разделы объясняют расширения до<std::integral_constant>, предоставленные<hana::integral_constant>.

Arithmetic operators

<hana::integral_constant>предоставляет операторы арифметики, которые возвращают<hana::integral_constant>s, чтобы облегчить написание арифметики времени компиляции:

BOOST_HANA_CONSTANT_CHECK(hana::int_c<1> + hana::int_c<3> == hana::int_c<4>);
// Mixed-type operations are supported, but only when it involves a
// promotion, and not a conversion that could be lossy.
BOOST_HANA_CONSTANT_CHECK(hana::size_c<3> * hana::ushort_c<5> == hana::size_c<15>);
BOOST_HANA_CONSTANT_CHECK(hana::llong_c<15> == hana::int_c<15>);

Довольно важно понимать, что эти операторы возвращают другие<integral_constant>с, а не нормальные значения интегрального типа. На самом деле, все эти операторы работают примерно одинаково. Проще говоря, для оператора<@>,

integral_constant<T, x>{} @ integral_constant<T, y>{} == integral_constant<T, x @ y>{}

Тот факт, что операторы возвращают<Constant>s, очень важен, поскольку он позволяет сохранять всю информацию, известную во время компиляции, до тех пор, пока она используется только с другими значениями, известными во время компиляции. Интересно также отметить, что всякий раз, когда<integral_constant>сочетается с нормальным значением времени выполнения, результатом будет значение времени выполнения (из-за неявного преобразования). В общем, это дает нам следующую таблицу.

left operand right operand result
integral_constant integral_constant integral_constant
integral_constant runtime runtime
runtime integral_constant runtime
runtime runtime runtime

Полный спектр предоставляемых операторов

  • Арифметика: бинарная+, двоичный-,/,*,%, унарный+, унарный-
  • ~,&,|,^,<<,>>
  • ==,!=,<,<=,>,>=
  • Логика:||,&&,!

Construction with user-defined literals

<integral_constant>s типа<long long>могут быть созданы с<_c>определяемым пользователем буквальным, который содержится в<literals>пространстве имен:

using namespace hana::literals; // contains the _c suffix
BOOST_HANA_CONSTANT_CHECK(1234_c == hana::llong_c<1234>);
BOOST_HANA_CONSTANT_CHECK(-1234_c == hana::llong_c<-1234>);
BOOST_HANA_CONSTANT_CHECK(1_c + (3_c * 4_c) == hana::llong_c<1 + (3 * 4)>);

Modeled concepts

  1. ConstantиIntegralConstant
    integral_constantявляется моделью концепцииIntegralConstantнаиболее очевидным из возможных способов. В частности,
    integral_constant::value== v// типа T
    МодельConstantестественно вытекает из моделиIntegralConstant, т.е.
    значение>() == v// типа T
    The model of Constant follows naturally from the model of IntegralConstant, i.e.
    value<integral_constant<T, v>>() == v // of type T
    [ORIG_END] -->
  2. Comparable,Orderable,Logical,Monoid,Group,RingиEuclideanRing,Hashable
    Эти модели являются именно теми, которые предусмотрены дляConstants, которые документированы в их соответствующих концепциях.

Synopsis of associated functions

template<bool b>
using bool_ = integral_constant< bool, b >
 
using true_ = bool_< true >
 
using false_ = bool_< false >
 
template<char c>
using char_ = integral_constant< char, c >
 
template<short i>
using short_ = integral_constant< short, i >
 
template<unsigned short i>
using ushort_ = integral_constant< unsigned short, i >
 
template<int i>
using int_ = integral_constant< int, i >
 
template<unsigned int i>
using uint = integral_constant< unsigned int, i >
 
template<long i>
using long_ = integral_constant< long, i >
 
template<unsigned long i>
using ulong = integral_constant< unsigned long, i >
 
template<long long i>
using llong = integral_constant< long long, i >
 
template<unsigned long long i>
using ullong = integral_constant< unsigned long long, i >
 
template<std::size_t i>
using size_t = integral_constant< std::size_t, i >
 
template<typename T , T v>
constexpr integral_constant< T, v > integral_c {}
 Creates an integral_constant holding the given compile-time value. More...
 
template<bool b>
constexpr bool_< b > bool_c {}
 
constexpr auto true_c = bool_c<true>
 
constexpr auto false_c = bool_c<false>
 
template<char c>
constexpr char_< c > char_c {}
 
template<short i>
constexpr short_< i > short_c {}
 
template<unsigned short i>
constexpr ushort_< i > ushort_c {}
 
template<int i>
constexpr int_< i > int_c {}
 
template<unsigned int i>
constexpr uint< i > uint_c {}
 
template<long i>
constexpr long_< i > long_c {}
 
template<unsigned long i>
constexpr ulong< i > ulong_c {}
 
template<long long i>
constexpr llong< i > llong_c {}
 
template<unsigned long long i>
constexpr ullong< i > ullong_c {}
 
template<std::size_t i>
constexpr size_t< i > size_c {}
 
template<char... c>
constexpr auto operator""_c ()
 Creates a hana::integral_constant from a literal. More...
 

Friends

template<typename X , typename Y >
constexpr auto operator+ (X &&x, Y &&y)
 Equivalent to hana::plus
 
template<typename X , typename Y >
constexpr auto operator- (X &&x, Y &&y)
 Equivalent to hana::minus
 
template<typename X >
constexpr auto operator- (X &&x)
 Equivalent to hana::negate
 
template<typename X , typename Y >
constexpr auto operator* (X &&x, Y &&y)
 Equivalent to hana::mult
 
template<typename X , typename Y >
constexpr auto operator/ (X &&x, Y &&y)
 Equivalent to hana::div
 
template<typename X , typename Y >
constexpr auto operator% (X &&x, Y &&y)
 Equivalent to hana::mod
 
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
 
template<typename X , typename Y >
constexpr auto operator|| (X &&x, Y &&y)
 Equivalent to hana::or_
 
template<typename X , typename Y >
constexpr auto operator&& (X &&x, Y &&y)
 Equivalent to hana::and_
 
template<typename X >
constexpr auto operator! (X &&x)
 Equivalent to hana::not_
 
template<typename X , typename Y >
constexpr auto operator< (X &&x, Y &&y)
 Equivalent to hana::less
 
template<typename X , typename Y >
constexpr auto operator> (X &&x, Y &&y)
 Equivalent to hana::greater
 
template<typename X , typename Y >
constexpr auto operator<= (X &&x, Y &&y)
 Equivalent to hana::less_equal
 
template<typename X , typename Y >
constexpr auto operator>= (X &&x, Y &&y)
 Equivalent to hana::greater_equal
 

Static Public Member Functions

template<typename F >
static constexpr void times (F &&f)
 Call a function n times. More...
 

Associated functions

template<typename T, T v>
template<bool b>
using bool_ = integral_constant<bool, b>
related
template<typename T, T v>
using true_ = bool_<true>
related
template<typename T, T v>
using false_ = bool_<false>
related
template<typename T, T v>
template<char c>
using char_ = integral_constant<char, c>
related
template<typename T, T v>
template<short i>
using short_ = integral_constant<short, i>
related
template<typename T, T v>
template<unsigned short i>
using ushort_ = integral_constant<unsigned short, i>
related
template<typename T, T v>
template<int i>
using int_ = integral_constant<int, i>
related
template<typename T, T v>
template<unsigned int i>
using uint = integral_constant<unsigned int, i>
related
template<typename T, T v>
template<long i>
using long_ = integral_constant<long, i>
related
template<typename T, T v>
template<unsigned long i>
using ulong = integral_constant<unsigned long, i>
related
template<typename T, T v>
template<long long i>
using llong = integral_constant<long long, i>
related
template<typename T, T v>
template<unsigned long long i>
using ullong = integral_constant<unsigned long long, i>
related
template<typename T, T v>
template<std::size_t i>
using size_t = integral_constant<std::size_t, i>
related
template<typename T, T v>
template<typename T , T v>
constexpr integral_constant<T, v> integral_c {}
related

<integral_constant>Для того, чтобы создать<integral_constant>.

В частности,<integral_c<T, v>>является<hana::integral_constant>удерживающим значение времени компиляции<v>интегрального типа<T>.

Template Parameters
TВеличина, которая должна быть в<integral_constant>. Это должен быть интегральный тип.
vЦелостное значение, удерживаемое в<integral_constant>.

Example

BOOST_HANA_CONSTANT_CHECK(hana::integral_c<int, 2> == hana::int_c<2>);
static_assert(decltype(hana::integral_c<int, 2>)::value == 2, "");
template<typename T, T v>
template<bool b>
constexpr bool_<b> bool_c {}
related
template<typename T, T v>
constexpr auto true_c = bool_c<true>
related
template<typename T, T v>
constexpr auto false_c = bool_c<false>
related
template<typename T, T v>
template<char c>
constexpr char_<c> char_c {}
related
template<typename T, T v>
template<short i>
constexpr short_<i> short_c {}
related
template<typename T, T v>
template<unsigned short i>
constexpr ushort_<i> ushort_c {}
related
template<typename T, T v>
template<int i>
constexpr int_<i> int_c {}
related
template<typename T, T v>
template<unsigned int i>
constexpr uint<i> uint_c {}
related
template<typename T, T v>
template<long i>
constexpr long_<i> long_c {}
related
template<typename T, T v>
template<unsigned long i>
constexpr ulong<i> ulong_c {}
related
template<typename T, T v>
template<long long i>
constexpr llong<i> llong_c {}
related
template<typename T, T v>
template<unsigned long long i>
constexpr ullong<i> ullong_c {}
related
template<typename T, T v>
template<std::size_t i>
constexpr size_t<i> size_c {}
related
template<char... c>
constexpr auto operator""_c ( )
related

Создает<hana::integral_constant>из букв.

Буквальный анализируется во время компиляции, и результат возвращается как<llong<...>>.

Note
We use llong<...> instead of ullong<...> because using an unsigned type leads to unexpected behavior when doing stuff like -1_c. If we used an unsigned type, -1_c would be something like ullong<-1> which is actually ullong<something huge>.

Example

using namespace hana::literals; // contains the _c suffix
BOOST_HANA_CONSTANT_CHECK(1234_c == hana::llong_c<1234>);
BOOST_HANA_CONSTANT_CHECK(-1234_c == hana::llong_c<-1234>);
BOOST_HANA_CONSTANT_CHECK(1_c + (3_c * 4_c) == hana::llong_c<1 + (3 * 4)>);

Member Function Documentation

template<typename T, T v>
template<typename F >
static constexpr void boost::hana::integral_constant< T, v >::times ( F &&  f)
static

Вызов функции n раз.

<times>позволяет использовать нулевую функцию<n>раз:

должен быть расширен любым достойным компилятором для

f(); f(); f();

Это может быть полезно в нескольких контекстах, например, для раскрутки петли:

std::string s;
for (char c = 'x'; c <= 'z'; ++c)
hana::int_<5>::times([&] { s += c; });
BOOST_HANA_RUNTIME_CHECK(s == "xxxxxyyyyyzzzzz");

Обратите внимание, что<times>действительно является объектом статической функции, а не просто статической функцией. Это позволяет<int_<n>::times>перейти к алгоритмам более высокого порядка:

std::string s;
BOOST_HANA_CONSTEXPR_LAMBDA auto functions = hana::make_tuple(
[&] { s += "x"; },
[&] { s += "y"; },
[&] { s += "z"; }
);
hana::for_each(functions, hana::int_<5>::times);
BOOST_HANA_RUNTIME_CHECK(s == "xxxxxyyyyyzzzzz");

Кроме того, поскольку к статичным элементам можно получить доступ с использованием синтаксиса<.>и<::>, можно воспользоваться этим (лазейкой?) для вызова<times>на объекты, а также на типы:

std::string s;
for (char c = 'x'; c <= 'z'; ++c)
hana::int_c<5>.times([&] { s += c; });
BOOST_HANA_RUNTIME_CHECK(s == "xxxxxyyyyyzzzzz");
Note
times is equivalent to the hana::repeat function, which works on an arbitrary IntegralConstant.

Иногда полезно знать индекс, на котором мы находимся внутри функции. Это можно сделать с помощью<times.with_index>:

std::vector<int> v;
hana::int_<5>::times.with_index([&](auto index) { v.push_back(index); });
BOOST_HANA_RUNTIME_CHECK(v == std::vector<int>{0, 1, 2, 3, 4});

Помните, что<times>являетсяфункциональным объектоми, следовательно, может иметь подобъекты.<with_index>— это просто функциональный объект, вложенный внутрь<times>, который позволяет использовать этот приятный маленький интерфейс. Также отметим, что индексы, переданные функции<integral_constant>s; они известны во время компиляции. Следовательно, мы можем делать с ними компиляции времени, такие как индексация внутри кортежа:

constexpr auto xs = hana::tuple_c<int, 0, 1, 2>;
hana::int_<3>::times.with_index([xs](auto index) {
BOOST_HANA_CONSTANT_CHECK(xs[index] == index);
});
Note
times.with_index(f) guarantees that the calls to f will be done in order of ascending index. In other words, f will be called as f(0), f(1), f(2), etc., but with integral_constants instead of normal integers. Side effects can also be done in the function passed to times and times.with_index.

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




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



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


реклама


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

Время компиляции файла: 2024-08-30 11:47:00
2025-07-04 22:54:35/0.0092880725860596/0