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

Boost.Hana: boost::hana::map< implementation_defined > Struct Template Reference

Boost , ,

Boost.Hana  1.0.1
Your standard library for metaprogramming
 Базовый ассоциативный контейнер, требующий уникальных ключей<Comparable>и<Hashable>.

Порядок элементов карты не уточняется. Кроме того, все клавиши должны быть<Hashable>, а любые две клавиши с одинаковыми хэшами должны быть<Comparable>друг с другом во время компиляции.

Note
The actual representation of a hana::map is implementation-defined. In particular, one should not take for granted the order of the template parameters and the presence of any additional constructors or assignment operators than what is documented. The canonical way of creating a hana::map is through hana::make_map.

Modeled concepts

  1. Comparable
    Две карты равны, все их ключи равны и связаны с равными значениями.
    // Авторское право Louis Dionne 2013-2016
    // Распространяется под лицензией Boost Software License, версия 1.0.
    // (См. сопроводительный файл LICENSE.md или копию на http://boost.org/LICENSE_1_0.txt)
    #include<boost/hana/assert.hpp>
    #include<boost/hana/integral_constant.hpp>
    #include<boost/hana/map.hpp>
    #include<boost/hana/pair.hpp>
    #include<boost/hana/type.hpp>
    #include
    пространство именhana =boost::hana;
    с использованием пространства именstd::буквы;
    intmain() {
    Boost_HANA_RUNTIME_CHECK
    hana::make_map(]
    hana::make_pair(hana::char_c<'a'>,"foobar"s),
    hana::make_pair (hana::type_c,nullptr
    )
    ==
    hana::make_map()
    hana::make_pair(hana::type_c,void*)0),
    hana::make_pair(hana::char_c<'a'>,"foobar"
    ;
    }
    [ORIG_END] -->
  2. Searchable
    Карту можно искать по ее ключам с предикатом, дающим время компиляцииLogical. Также обратите внимание, чтоoperator[]можно использовать вместоat_key.
    // Авторское право Louis Dionne 2013-2016
    // Распространяется по лицензии Boost Software License, Version 1.0.
    // [См. сопровождающий файл LICENSE.md или копию по http://boost.org/LICENSE_116]
    [113[ORIG_END] -->
  3. Foldable
    Складка карты эквивалентна складыванию списка пар ключ/значение, которые она содержит. В частности, поскольку этот список не гарантируется в каком-либо определенном порядке, складывание карты с операцией, которая не является одновременно коммутативной и ассоциативной, приведет к недетерминистическому поведению.
    // Авторское право Louis Dionne 2013-2016
    // Распространяется по лицензии Boost Software License, Version 1.0.
    // [См. сопроводительный файл LICENSE.md или копию по адресу http://boost.org/LICENSE_1_0.txt]
    При наличии карты пар (ключ, значение), возвращает карту пар (значение, ключ).
    // Это требует, чтобы ключи и значения были сопоставимы по времени компиляции.
    автокарта{
    возвращение[автовозвращениехана:возвращениехана::вставка[пара];хана::вторая[пара]];
    ]
    ] автом = хана::make_map
    хана::make_pair [хана::type_c<1>],
    хана::make_pair [хана::type_c)
    ;
    BOOST_HANA_CONSTANT_CHECK(invert(m) ==
    hana::make_map
    hana::make_pair(hana::int_c, hana::type_c),
    hana::make_pair(hana::int_c),
    ][ORIG_END] -->

Conversion from any Foldable

<Foldable>из<Product>может быть преобразовано в<hana::map>с<hana::to<hana::map_tag>>или эквивалентно<hana::to_map>. Если<Foldable>содержит дубликаты ключей, сохраняется только значение, связанное с первым появлением каждого ключа.

// 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 <boost/hana/assert.hpp>
#include <boost/hana/core/to.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
#include <string>
namespace hana = boost::hana;
using namespace std::literals;
int main() {
auto xs = hana::make_tuple(
hana::make_pair(hana::type_c<int>, "abcd"s),
hana::make_pair(hana::type_c<void>, 1234),
hana::make_pair(hana::type_c<int>, nullptr)
);
BOOST_HANA_RUNTIME_CHECK(
hana::to<hana::map_tag>(xs) == hana::make_map(
hana::make_pair(hana::type_c<int>, "abcd"s),
hana::make_pair(hana::type_c<void>, 1234)
)
);
}

Synopsis of associated functions

template<>
constexpr auto make< map_tag >
 Function object for creating a hana::map. More...
 
constexpr auto make_map = make<map_tag>
 Alias to make<map_tag>; provided for convenience. More...
 
constexpr auto to_map = to<map_tag>
 Equivalent to to<map_tag>; provided for convenience. More...
 
constexpr auto keys
 Returns a Sequence of the keys of the map, in unspecified order. More...
 
constexpr auto values
 Returns a Sequence of the values of the map, in unspecified order. More...
 
constexpr auto insert
 Inserts a new key/value pair in a map. More...
 
constexpr auto erase_key
 Removes a key/value pair from a map. 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 map ()=default
 Default-construct a map. This constructor only exists when all the elements of the map are default-constructible.
 
constexpr map (map const &other)=default
 Copy-construct a map from another map. This constructor only exists when all the elements of the map are copy-constructible.
 
constexpr map (map &&other)=default
 Move-construct a map from another map. This constructor only exists when all the elements of the map are move-constructible.
 
template<typename Key >
decltype(auto) constexpr operator[] (Key &&key)
 Equivalent to hana::at_key
 

Associated functions

template<typename implementation_defined >
template<>
constexpr auto make< map_tag >
related
Initial value:
= [](auto&& ...pairs) {
return map<implementation_defined>{forwarded(pairs)...};
}

Функциональный объект для создания<hana::map>.

Учитывая ноль или более<Product>, представляющих ассоциации ключ/значение,<make<map_tag>>возвращает<hana::map>, связывающее эти ключи с этими значениями.

<make<map_tag>>требует, чтобы все ключи были уникальными и имели разные хэши. Если вам нужно создать карту с дублированными ключами или с ключами, хэши которых могут столкнуться, используйте<hana::to_map>или вставьте<(key, value)>пары на пустую карту последовательно. Однако имейте в виду, что это будет гораздо более интенсивным, чем использование<make<map_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)
#include <boost/hana/assert.hpp>
#include <boost/hana/core/make.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/type.hpp>
#include <string>
namespace hana = boost::hana;
using namespace std::literals;
int main() {
BOOST_HANA_RUNTIME_CHECK(
hana::make_map(
hana::make_pair(hana::int_c<1>, "foobar"s),
hana::make_pair(hana::type_c<void>, 1234)
)
==
hana::make<hana::map_tag>(
hana::make_pair(hana::int_c<1>, "foobar"s),
hana::make_pair(hana::type_c<void>, 1234)
)
);
}
template<typename implementation_defined >
constexpr auto make_map = make<map_tag>
related

<make<map_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)
#include <boost/hana/assert.hpp>
#include <boost/hana/core/make.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/type.hpp>
#include <string>
namespace hana = boost::hana;
using namespace std::literals;
int main() {
BOOST_HANA_RUNTIME_CHECK(
hana::make_map(
hana::make_pair(hana::int_c<1>, "foobar"s),
hana::make_pair(hana::type_c<void>, 1234)
)
==
hana::make<hana::map_tag>(
hana::make_pair(hana::int_c<1>, "foobar"s),
hana::make_pair(hana::type_c<void>, 1234)
)
);
}
template<typename implementation_defined >
constexpr auto to_map = to<map_tag>
related

<to<map_tag>>Для удобства.

template<typename implementation_defined >
constexpr auto keys
related
Initial value:
= [](auto&& map) {
return implementation_defined;
}

Возвращает 20 ключей карты в неуказанном порядке.

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 <boost/hana/assert.hpp>
#include <boost/hana/contains.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/keys.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/permutations.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
#include <string>
namespace hana = boost::hana;
using namespace std::literals;
int main() {
auto m = hana::make_map(
hana::make_pair(hana::int_c<1>, "foobar"s),
hana::make_pair(hana::type_c<void>, 1234)
);
// The order of the keys is unspecified.
BOOST_HANA_CONSTANT_CHECK(
hana::keys(m) ^hana::in^ hana::permutations(hana::make_tuple(hana::int_c<1>, hana::type_c<void>))
);
}
template<typename implementation_defined >
constexpr auto values
related
Initial value:
= [](auto&& map) -> decltype(auto) {
return implementation_defined;
}

Возвращает<Sequence>значения карты в неуказанном порядке.

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 <boost/hana/assert.hpp>
#include <boost/hana/contains.hpp>
#include <boost/hana/integral_constant.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/permutations.hpp>
#include <boost/hana/tuple.hpp>
#include <boost/hana/type.hpp>
#include <string>
namespace hana = boost::hana;
using namespace std::literals;
int main() {
auto m = hana::make_map(
hana::make_pair(hana::int_c<1>, "foobar"s),
hana::make_pair(hana::type_c<void>, 1234)
);
// The order of the values is unspecified.
BOOST_HANA_RUNTIME_CHECK(
hana::values(m) ^hana::in^ hana::permutations(hana::make_tuple("foobar"s, 1234))
);
}
template<typename implementation_defined >
constexpr auto insert
related
Initial value:
= [](auto&& map, auto&& pair) {
return tag-dispatched;
}

Вставляет новую пару ключ/значение в карту.

При наличии<(key, value)>пары<insert>вставляет эту новую пару в карту. Если карта уже содержит этот ключ, ничего не делается и карта возвращается как есть.

Parameters
mapНа карте, в которую вставить пару<(key,value)>.
pairПроизвольная<Product>пара<(key, value)>для вставки на карту.<key>,<Comparable>,<Comparable>.

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 <boost/hana/assert.hpp>
#include <boost/hana/insert.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/type.hpp>
#include <string>
namespace hana = boost::hana;
using namespace std::literals;
int main() {
auto m = hana::make_map(
hana::make_pair(hana::type_c<int>, "abcd"s),
hana::make_pair(hana::type_c<void>, 1234)
);
BOOST_HANA_RUNTIME_CHECK(
hana::insert(m, hana::make_pair(hana::type_c<float>, 'x')) ==
hana::make_map(
hana::make_pair(hana::type_c<int>, "abcd"s),
hana::make_pair(hana::type_c<void>, 1234),
hana::make_pair(hana::type_c<float>, 'x')
)
);
BOOST_HANA_RUNTIME_CHECK(hana::insert(m, hana::make_pair(hana::type_c<void>, 'x')) == m);
}
template<typename implementation_defined >
constexpr auto erase_key
related
Initial value:
= [](auto&& map, auto&& key) {
return tag-dispatched;
}

Удаление пары ключ/значение с карты.

Возвращает новый<hana::map>, содержащий все элементы оригинала, за исключением пары<(key, value)>, которая<key>сравнивает<equal>с заданным ключом. Если карта не содержит такого элемента, возвращается новая карта, равная оригиналу.

Parameters
mapКарта, на которой можно стереть<key>.
keyКлюч для удаления с карты. Это должно быть время сбора<Comparable>.

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 <boost/hana/assert.hpp>
#include <boost/hana/erase_key.hpp>
#include <boost/hana/map.hpp>
#include <boost/hana/pair.hpp>
#include <boost/hana/string.hpp>
#include <boost/hana/type.hpp>
#include <string>
namespace hana = boost::hana;
using namespace std::literals;
int main() {
auto m = hana::make_map(
hana::make_pair(hana::type_c<int>, "abcd"s),
hana::make_pair(hana::type_c<void>, 1234),
hana::make_pair(BOOST_HANA_STRING("foobar!"), hana::type_c<char>)
);
BOOST_HANA_RUNTIME_CHECK(
hana::erase_key(m, BOOST_HANA_STRING("foobar!")) ==
hana::make_map(
hana::make_pair(hana::type_c<int>, "abcd"s),
hana::make_pair(hana::type_c<void>, 1234)
)
);
BOOST_HANA_RUNTIME_CHECK(hana::erase_key(m, hana::type_c<char>) == m);
}

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




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


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

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

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