AnyAny
v1.0.0
유형 삭제를 통한 효율적인 동적 다형성을 위한 라이브러리(C++17 이상)
목표는 효율성, 이해 가능성 및 확장성입니다.
땡그랑, gcc, msvc 
How to build?라이브러리의 기본 유형 지우기 부분은 방법 (지우고 난 후 사용하려는 유형의 부분)에 대한 설명입니다.
void draw() 사용하여 유형을 지우는 것을 만들어 보겠습니다.
<anyany/anyany_macro.hpp>에는 anyany_method 매크로가 있습니다. 예를 들어, int 및 float를 허용하고 float를 반환하는 'foo' 메서드의 경우
# include < anyany/anyany_macro.hpp >
anyany_method (foo, (&self, int i, float f) requires(self.foo(i, f)) -> float);
...
void example (aa::any_with<foo> obj) {
if (obj. has_value ())
float x = obj. foo ( 5 , 3 . 14f ); // all works
obj = some_type_with_foo{};
obj = some_other_type_with_foo ();
} // For each type T do value.draw()
struct Draw {
template < typename T>
static void do_invoke ( const T& self) {
self. draw ();
}
}; 유형 삭제를 위해 Draw 사용할 수 있습니다.
# include < anyany/anyany.hpp >
using any_drawable = aa::any_with<Draw>; 이제 any_drawable 사용하여 .draw()로 모든 유형을 저장할 수 있습니다.
// some types with .draw()
struct Circle {
void draw () const {
std::cout << " Draw Circle n " ;
}
};
struct Square {
void draw () const {
std::cout << " Draw Square n " ;
}
};
int main () {
any_drawable shape = Circle{};
aa::invoke<Draw>(shape); // prints "Draw Circle"
shape = Square{};
aa::invoke<Draw>(shape); // prints "Draw Square"
// see /examples folder for more
}가상 함수, 상속, 포인터, 메모리 관리 등은 없습니다! 멋진!
원하는 만큼의 메소드를 추가할 수 있습니다.
using any_my = aa::any_with<Draw, Run, aa::copy>; 잠깐, 알겠어...? 예, 기본적으로 aa::any_with 소멸자만 있습니다. aa::copy 메서드를 추가하여 복사 및 이동 가능하게 하거나 aa::move 를 추가하여 이동만 가능하게 할 수 있습니다.
사전 정의된 방법 :
any_with 복사 및 이동 가능하게 만들고 참조용으로 aa::materialize 활성화합니다(이에는 aa::destroy 메서드도 필요함)
copy_with<Alloc, SooS> 도 있습니다. 이를 통해 사용자 지정 할당자 및 Small Object Optimization Size( aa::basic_any_with )를 사용할 때 복사가 가능해집니다.
'any_with'를 이동 가능하게 만듭니다.
참고: any_with 에 대한 이동 생성자와 이동 할당 연산자는 항상 noException입니다.
any_with , poly_ref /...etc에 대한 std::hash 특수화를 활성화합니다. any_with 비어 있으면 해시 == 0입니다.
참고: poly_ptr 기본적으로 std::hash 로 특수화되어 있지만 포인터와 유사한 해시입니다.
vtable에 RTTI를 추가하여 aa::any_cast , aa::type_switch , aa::visit_invoke 활성화합니다.
또한 any_with / poly_ref /...etc에 대해 .type_descriptor() -> aa::descriptor_t 추가합니다.
any_with / poly_ref /...등에 대해 operator== 활성화합니다.
동일한 유형(또는 둘 다 비어 있음)을 포함하고 저장된 값이 동일한 경우 두 객체는 동일합니다.
any_with / poly_ref /...etc에 대해 operator<=> 및 operator== 활성화합니다.
참고:operpator<=>는 항상 std::partial_ordering 반환합니다.
두 객체가 동일한 유형을 포함하지 않으면 unordered 반환하고, 그렇지 않으면 포함된 객체에 대해 operator <=> 의 결과를 반환합니다.
참고: 둘 다 비어 있으면 std::partial_ordering::equivalent 반환합니다.
any_with / poly_ref /...etc에 대해 R operator()(Args...) 추가합니다.
참고: const , noexcept 및 const noexcept 서명도 지원됩니다.
예:
// stateful::cref is a lightweight thing,
// it stores vtable in itself(in this case only one function ptr)
// and const void* to value
// This is most effective way to erase function
template < typename Signature>
using function_ref = aa::stateful::cref<aa::call<Signature>>;
void foo (function_ref< int ( float ) const > ref) {
int result = ref ( 3.14 );
}
소멸자를 추가합니다( any_with 기본적으로 포함되어 있음). 그러나 수명을 수동으로 관리하기 위해 aa::poly_ptr 과 함께 사용하고 싶을 수도 있습니다. 또한 참조를 위해 aa::materialize 활성화합니다(aa::copy도 필요함)
메소드 에 대한 모든 세부 정보를 보려면 anyany.hpp의 method 개념을 참조하세요.
다형성 유형:
any_with<Methods...>basic_any_with<Methods...>poly_ref<Methods...>poly_ptr<Methods...>cref<Methods...>cptr<Methods...>stateful::ref<Methods...>stateful::cref<Methods...>행위:
any_cast<T>invoke<Method>type_switchvisit_invoke다형성 컨테이너:
variant_swarm<Ts...>data_parallel_vector<T, Alloc> template < typename T>
concept method = /* ... */ ; // see anyany.hpp
// true if type can be used as poly traits argument in any_cast / type_switch / visit_invoke etc
template < typename T>
concept poly_traits = requires(T val, int some_val) {
{ val. get_type_descriptor (some_val) } -> std::same_as< descriptor_t >;
{ val. to_address (some_val) };
};다형성 계층(LLVM과 유사한 유형 ID, 가상 함수 등)에 대한 특성을 정의할 수 있습니다.
라이브러리에는 두 가지 특성이 내장되어 있습니다(자신만의 구현을 위한 예로 사용할 수 있습니다).
예를 들어, Method 를 사용하여 any_with 또는 poly_ref 에 의해 생성된 유형의 .foo() 메소드를 갖고 싶습니다.
그런 다음 plugins 사용해야 합니다.
struct Foo {
template < typename T>
static void do_invoke (T&) { /* do something */ }
// any_with<Foo> will inherit plugin<any_with<Foo>>
template < typename CRTP>
struct plugin {
void foo () const {
auto & self = * static_cast < const CRTP*>( this );
// Note: *this may not contain value, you can check it by calling self.has_value()
aa::invoke<Foo>(self);
}
};
};
//
any_with<Foo> val = /* ... */ ;
val.foo(); // we have method .foo from plugin!
참고: 플러그인에서 다른 플러그인을 상속하여 다른 플러그인을 '섀도우/오버라이드'할 수 있습니다(상속이 비공개인 경우에도).
예를 들어 aa::spaceship/aa::copy_with 플러그인을 참조하세요.
또한 aa::plugin<Any, Method>를 Method에 대해 전문화하거나 일부 요구 사항이 있는 'Any'에 대해서도 전문화할 수 있습니다.
any_with원하는 수의 Methods를 허용하고 해당 Methods를 지원하는 모든 값을 보유할 수 있는 유형을 생성합니다. 런타임 개념과 유사
참고: 강제 할당을 위한 'aa::force_stable_pointers' 태그가 있으므로 이동 후 any_with<...> 에 대한 poly_ptr/cptr 무효화되지 않습니다.
참고: aa::unreachable_allocator 는 basic_any_with<unreachable_allocator, ...> 가 메모리 할당을 시도하는 경우 컴파일을 중단합니다. 따라서 유형을 할당하지 않도록 강제할 수 있습니다.
// All constructors and move assign operators are exception safe
// move and move assign always noexcept
// See 'construct_interface' alias in anyany.hpp and 'struct plugin'for details how it works(comments)
struct Any : construct_interface<basic_any<Alloc, SooS, Methods...>, Methods...>{
// aliases to poly ref/ptr
using ptr = /* ... */ ;
using ref = /* ... */ ;
using const_ptr = /* ... */ ;
using const_ref = /* ... */ ;
// operator & for getting poly ptr
poly_ptr<Methods...> operator &() noexcept ;
const_poly_ptr<Methods...> operator &() const noexcept ;
// main constructors
// creates empty
constexpr Any ();
Any ( auto && value); // from any type
Any ( const Any&) requires aa::copy
Any& operator =( const Any&) requires aa::move and aa::copy
Any (Any&&) noexcept requires aa::move;
Any& operator =(Any&&) requires method aa::move;
// observers
bool has_value () const noexcept ;
// returns true if poly_ptr/ref to *this will not be invalidated after moving value
bool is_stable_pointers () const noexcept
// returns count of bytes sufficient to store current value
// (not guaranteed to be smallest)
// return 0 if !has_value()
size_t sizeof_now() const noexcept ;
// returns descriptor_v<void> if value is empty
type_descriptor_t type_descriptor () const noexcept requires aa::type_info;
// forces that after creation is_stable_pointers() == true (allocates memory)
template < typename T>
Any ( force_stable_pointers_t , T&& value);
// also emplace constructors(std::in_place_type_t<T>), initiaizer list versions
// same with force_stable_pointers_t tag etc etc
// same with Alloc...
// modifiers
// emplaces value in any, if exception thrown - any is empty(use operator= if you need strong exception guarantee here)
template < typename T, typename ... Args>
std:: decay_t <T>& emplace (Args&&...); // returns reference to emplaced value
template < typename T, typename U, typename ... Args>
std:: decay_t <T>& emplace (std::initializer_list<U> list, Args&&... args)
// postcondition: has_value() == false
void reset() noexcept ;
// see aa::equal_to description for behavior
bool operator ==( const Any&) const requires aa::spaceship || aa::equal_to;
// see aa::spaceship description for behavior
std::partial_ordering operator <=>( const Any&) const requires aa::spaceship;
// ... interface from plugins for Methods if presented ...
};
모든 생성자와 복사/이동 할당 연산자에는 강력한 예외 보장이 있습니다.
참고: 유형에 이동 생성자 제외가 없으면 성능이 실제로 향상될 수 있습니다(std::Vector의 경우처럼).
예:
using any_printable = aa::any_with<Print, aa::move>;basic_any_with any_with 와 동일하지만 사용자 지정 할당 및 작은 개체 최적화 버퍼 크기가 있습니다. 복사 가능한 basic_any_with 필요한 경우 copy_with 사용하세요.
template < typename Alloc, size_t SooS, TTA... Methods>
using basic_any_with = /* ... */ ;poly_ref비소유, 항상 null이 아님, 경량(~=void*)
poly_ref<Methods...> 암시적으로 더 적은 수의 메소드로 변환 가능합니다.
poly_ref<A, B, C> poly_ref<A, B> , poly_ref<A> , poly_ref<B> ... 등으로 변환 가능합니다.
이는 실제로 필요한 메서드 만 함수 인터페이스에 추가할 수 있음을 의미합니다. 그런 다음 any_with 유형에 Method를 추가하면 abi/api 중단이 없습니다.
// you can invoke this function with any poly_ref<..., A, ...>
void foo (poly_ref<A>); template < template < typename > typename ... Methods>
struct poly_ref {
poly_ref ( const poly_ref&) = default ;
poly_ref (poly_ref&&) = default ;
poly_ref& operator =(poly_ref&&) = default ;
poly_ref& operator =( const poly_ref&) = default ;
// only explicit rebind reference after creation
void operator =( auto &&) = delete ;
descriptor_t type_descriptor () const noexcept requires aa::type_info;
// from mutable lvalue
template <not_const_type T> // not shadow copy ctor
poly_ref (T& value) noexcept
poly_ptr<Methods...> operator &() const noexcept ;
// ... interface from plugins for Methods if presented ...
}const_poly_ref poly_ref 와 동일하지만 poly_ref 및 const T& 에서 생성할 수 있습니다.
aa::cref aa::const_poly_ref 에 대한 템플릿 별칭입니다.
참고: 수명을 연장하지 마십시오.
poly_ptr비소유, null 허용, 경량(~=void*)
poly_ptr<Methods...> 암시적으로 더 적은 수의 메소드로 변환 가능합니다.
poly_ptr<A, B, C> poly_ptr<A, B> , poly_ptr<A> , poly_ptr<B> ... 등으로 변환 가능합니다.
이는 실제로 필요한 메서드 만 함수 인터페이스에 추가할 수 있음을 의미합니다. 그런 다음 any_with 유형에 Method를 추가하면 abi/api 중단이 없습니다.
// you can invoke this function with any poly_ptr<..., A, ...>
void foo (poly_ptr<A>); 참고: poly_ptr 및 const_poly_ptr 간단하게 복사 가능하므로 std::atomic<poly_ptr<...>> 작동합니다.
template < template < typename > typename ... Methods>
struct poly_ptr {
poly_ptr () = default ;
poly_ptr (std:: nullptr_t ) noexcept ;
poly_ptr& operator =(std:: nullptr_t ) noexcept ;
poly_ptr (not_const_type auto * ptr) noexcept ;
// from non-const pointer to Any with same methods
template <any_x Any>
poly_ptr (Any* ptr) noexcept ;
// observers
// returns raw pointer to value
void * raw () const noexcept ;
// NOTE: returns unspecified value if *this == nullptr
const vtable<Methods...>* raw_vtable_ptr () const noexcept ;
// returns descriptor_v<void> is nullptr
descriptor_t type_descriptor () const noexcept requires aa::type_info;
bool has_value () const noexcept ;
bool operator ==(std:: nullptr_t ) const noexcept ;
explicit operator bool () const noexcept ;
// similar to common pointer operator* returns reference
poly_ref<Methods...> operator *() const noexcept ;
const poly_ref<Methods...>* operator ->() const noexcept ;
}const_poly_ptr poly_ptr 과 동일하지만, poly_ptr 및 const T* / Any* 에서 생성할 수 있습니다.
aa::cptr 은 aa::const_poly_ptr 에 대한 템플릿 별칭입니다.
stateful_ref aa::stateful::ref<Methods...> 자체에 vtable이 포함되어 있습니다.
또한 붕괴 없이 C-배열 및 함수에 대한 참조를 포함할 수 있습니다.
인터페이스는 매우 간단하며 T&/poly_ref 에서만 생성하고 호출합니다(예: aa::invoke 사용).
1-2개의 메소드를 삭제해야 하고 any_cast 사용할 필요가 없는 경우 최대 성능을 발휘합니다.
일반적인 사용 사례 - function_ref 생성
template < typename Signature>
using function_ref = aa::stateful::cref<aa::call<Signature>>;
bool foo ( int ) { return true ; }
void example (function_ref< bool ( int ) const > ref) {
ref ( 5 );
}
int main () {
example (&foo);
example ([]( int x) { return false ; });
}
stateful_cref stateful::ref 와 동일하지만 const T& 및 aa::cref 에서 생성될 수 있습니다.
any_castaa::type_info 메서드가 필요합니다.
Operator()가 포함된 기능적 개체:
std::any_cast로 작동 - T(copy), T&(take ref)로 변환할 수 있습니다(캐스트가 잘못된 경우 aa::bad_cast 발생).
또는 포인터(또는 폴리_ptr)를 전달할 수 있습니다(캐스트가 잘못된 경우 nullptr 반환).
T* ptr = any_cast<T>(&any);
예:
using any_comparable = aa::any_with<aa::copy, aa::spaceship, aa::move>;
void Foo () {
any_comparable value = 5 ;
value. emplace <std::vector< int >>({ 1 , 2 , 3 , 4 }); // constructed in-place
// any_cast returns pointer to vector<int>(or nullptr if any do not contain vector<int>)
aa::any_cast<std::vector< int >>( std::addressof (value))-> back () = 0 ;
// version for reference
aa::any_cast<std::vector< int >&>(value). back () = 0 ;
// version which returns by copy (or move, if 'value' is rvalue)
auto vec = aa::any_cast<std::vector< int >>(value);
}invoke any_with/ref/cref/stateful::ref/stateful::cref 첫 번째 인수로 받아들인 다음 모든 Method 의 인수를 받아들이고 Method를 호출하는 Operator()가 포함된 기능적 객체
arg가 const any_with 또는 cref 이면 const 메서드 만 허용됩니다.
전제조건: any.has_value() == true
예:
void example (any_with<Say> pet) {
if (!pet. has_value ())
return ;
// invokes Method `Say`, passes std::cout as first argument
aa::invoke<Say>(pet, std::cout);
}
void foo (std::vector<aa::poly_ref<Foo>> vec) {
// invokes Method `Foo` without arguments for each value in `vec`
std::ranges::for_each (vec, aa::invoke<Foo>);
}
type_switch 입력 인수 동적 유형을 기반으로 .case를 선택하고 이 동적 유형 또는 기본 함수를 사용하여 visitor 호출합니다.
또한 두 번째 템플릿 인수로 poly_traits 지원하므로 다중 특성이 있는 모든 유형을 지원합니다.
template < typename Result = void , poly_traits Traits = anyany_poly_traits>
struct type_switch_fn {
type_switch_fn (poly_ref<...>);
// invokes Fn if T contained
template < typename T, typename Fn>
type_switch_impl& case_ (Fn&& f);
// If value is one of Ts... F invoked (invokes count <= 1)
template < typename ... Ts, typename Fn>
type_switch_impl& cases (Fn&& f);
// if no one case succeded invokes 'f' with input poly_ref argument
template < typename Fn>
Result default_ (Fn&& f);
// if no one case succeded returns 'v'
Result default_ (Result v);
// if no one case succeded returns 'nullopt'
std::optional<Result> no_default ();
};
예:
Result val = aa::type_switch<Result>(value)
.case_< float >(foo1)
.case_< bool >(foo2)
.cases< char , int , unsigned char , double >(foo3)
.default_( 15 );visit_invoke 그것은... 런타임 과부하 해결입니다! aa::make_visit_invoke<Foos...> Args... 런타임 유형을 기반으로 오버로드 해결을 수행하는 .resolve(Args...) 메서드를 사용하여 오버로드 세트 객체를 생성합니다.
입력 인수를 허용하는 함수가 없으면 Resolve는 nullopt 반환합니다.
이 예는 매우 기본적입니다. 자세한 내용은 /examples/visit_invoke_example.hpp를 참조하세요.
예:
auto ship_asteroid = [](spaceship s, asteroid a) -> std::string { ... }
auto ship_star = [](spaceship s, star) -> std::string { ... }
auto star_star = [](star a, star b) -> std::string { ... }
auto ship_ship = [](spaceship a, spaceship b) -> std::string { ... }
// Create multidispacter
constexpr inline auto collision = aa::make_visit_invoke<std::string>(
ship_asteroid,
ship_star,
star_star,
ship_ship);
...
// Perform runtime overload resolution
std::optional<std::string> foo (any_with<A> a, any_with<B> b) {
return collision. resolve (a, b);
}
variant_swarm Container<std::variant<Types...>> 처럼 작동하지만 훨씬 더 효과적인 다형성 컨테이너 어댑터입니다.
지원되는 작업:
visit<Types...>(visitor) - 포함된 모든 유형의 값으로 visitor 호출합니다 Typesview<T> - T 유형의 모든 저장된 값이 포함된 컨테이너에 대한 참조를 반환합니다. 컨테이너는 기본적으로 std::vector 입니다.
template < template < typename > typename Container, typename ... Ts>
struct basic_variant_swarm {
// modifiers
void swap (basic_variant_swarm& other) noexcept ;
friend void swap (basic_variant_swarm& a, basic_variant_swarm& b) noexcept ;
// selects right container and inserts [it, sent) into it
template <std::input_iterator It>
requires (tt::one_of<std:: iter_value_t <It>, std::ranges:: range_value_t <Container<Ts>>...>)
auto insert (It it, It sent);
// insert and erase overloads for each type in Ts...
using inserters_type::erase;
using inserters_type::insert;
// observe
bool empty () const noexcept ;
// returns count values, stored in container for T
template <tt::one_of<Ts...> T>
requires (std::ranges::sized_range<container_for<T>>)
auto count () const ;
template <std:: size_t I>
requires (std::ranges::sized_range<decltype(std::get<I>(containers))>)
auto count () const ;
// returns count of values stored in all containers
constexpr auto size () const requires(std::ranges::sized_range<container_for<Ts>> && ...);
// returns tuple of reference to containers #Is
template <std:: size_t ... Is>
auto view ();
template <std:: size_t ... Is>
auto view () const ;
// returns tuple of reference to containers for Types
template <tt::one_of<Ts...>... Types>
auto view ();
template <tt::one_of<Ts...>... Types>
auto view () const ;
// visit
// visits with 'v' and passes its results into 'out_visitor' (if result is not void)
template <tt::one_of<Ts...>... Types>
void visit (visitor_for<Types...> auto && v, auto && out_visitor);
// ignores visitor results
template <tt::one_of<Ts...>... Types>
void visit (visitor_for<Types...> auto && v);
// visits with 'v' and passes its results into 'out_visitor' (if result is not void)
void visit_all (visitor_for<Ts...> auto && v, auto && out_visitor);
// ignores visitor results
constexpr void visit_all (visitor_for<Ts...> auto && v);
template <tt::one_of<Ts...>... Types, std::input_or_output_iterator Out>
constexpr Out visit_copy (visitor_for<Types...> auto && v, Out out);
template <tt::one_of<Ts...>... Types, std::input_or_output_iterator Out>
constexpr Out visit_copy (Out out);
// visits with 'v' and passes its results into output iterator 'out', returns 'out" after all
template <std::input_or_output_iterator Out>
constexpr Out visit_copy_all (visitor_for<Ts...> auto && v, Out out);
// passes all values into 'out' iterator, returns 'out' after all
template <std::input_or_output_iterator Out>
constexpr Out visit_copy_all (Out out);
// ...also const versions for visit...
};
예:
aa::variant_swarm< int , double , std::string> f;
// no runtime dispatching here, its just overloads
f.inesrt( " hello world " );
f.insert( 5 );
f.insert( 3.14 );
auto visitor = []( auto && x) {
std::cout << x << ' t ' ;
};
f.visit_all(visitor); // prints 5, 3.14, "hello world"data_parallel_vector 이 컨테이너는 std::vector<T> 처럼 동작하지만 필드를 별도로 저장합니다.
지원되는 작업: 이 인덱스의 모든 필드에 대한 범위를 가져오는 view<T> / view<I>
T 집계형이거나 튜플형 유형이어야 합니다.
참고: data_parallel_vector 임의 액세스 범위입니다. 참고: std::vector<bool> 특수화를 무시하고 bool에 대한 일반 벡터로 동작합니다.
template < typename T, typename Alloc>
struct data_parallel_vector {
using value_type = T;
using allocator_type = Alloc;
using difference_type = std:: ptrdiff_t ;
using size_type = std:: size_t ;
using reference = proxy; // similar to vector<bool>::reference type
using const_reference = const_proxy;
void swap (data_parallel_vector&) noexcept ;
friend void swap (data_parallel_vector&) noexcept ;
data_parallel_vector () = default ;
explicit data_parallel_vector ( const allocator_type& alloc);
data_parallel_vector (size_type count, const value_type& value,
const allocator_type& alloc = allocator_type());
explicit data_parallel_vector (size_type count, const allocator_type& alloc = allocator_type());
template <std::input_iterator It>
data_parallel_vector (It first, It last, const allocator_type& alloc = allocator_type());
data_parallel_vector ( const data_parallel_vector& other, const allocator_type& alloc);
data_parallel_vector (data_parallel_vector&& other, const allocator_type& alloc);
data_parallel_vector (std::initializer_list<value_type> init,
const allocator_type& alloc = allocator_type());
// copy-move all default
data_parallel_vector& operator =(std::initializer_list<T> ilist);
using iterator;
using const_iterator;
iterator begin ();
const_iterator begin () const ;
iterator end ();
const_iterator end () const ;
const_iterator cbegin () const ;
const_iterator cend () const ;
reference front ();
const_reference front () const ;
reference back ();
reference back () const ;
reference operator [](size_type pos);
const_reference operator [](size_type pos) const ;
size_type capacity () const ;
size_type max_size () const ;
// returns tuple of spans to underlying containers
template < typename ... Types>
auto view ();
template < typename ... Types>
auto view () const ;
template <std:: size_t ... Nbs>
auto view ();
template <std:: size_t ... Nbs>
auto view () const ;
bool empty () const ;
size_type size () const ;
bool operator ==( const data_parallel_impl&) const = default ;
iterator emplace (const_iterator pos, element_t <Is>... fields);
reference emplace_back ( element_t <Is>... fields);
void push_back ( const value_type& v);
void push_back (value_type&& v);
iterator erase (const_iterator pos);
iterator erase (const_iterator b, const_iterator e);
iterator insert (const_iterator pos, const value_type& value);
iterator insert (const_iterator pos, value_type&& value);
iterator insert (const_iterator pos, size_type count, const T& value);
template <std::input_iterator It>
iterator insert (const_iterator pos, It first, It last);
iterator insert (const_iterator pos, std::initializer_list<value_type> ilist);
void assign (size_type count, const value_type& value);
template <std::input_iterator It>
void assign (It first, It last);
void assign (std::initializer_list<T> ilist);
void clear ();
void pop_back ();
void reserve (size_type new_cap);
void resize (size_type sz);
void resize (size_type sz, const value_type& v);
void shrink_to_fit ();
};
예:
struct my_type {
int x;
float y;
bool l;
};
void foo () {
aa::data_parallel_vector<my_type> magic;
// ints, floats, bools are spans to all stored fields of my_type (&::x, &::y, &::l)
auto [ints, floats, bools] = magic;
magic. emplace_back ( 5 , 6 . f , true );
};콘텐츠 가져오기:
include (FetchContent)
FetchContent_Declare(
AnyAny
GIT_REPOSITORY https://github.com/kelbon/AnyAny
GIT_TAG origin/main
)
FetchContent_MakeAvailable(AnyAny)
target_link_libraries (MyTargetName anyanylib) add_subdirectory (AnyAny)
target_link_libraries (MyTargetName PUBLIC anyanylib)buildgit clone https://github.com/kelbon/AnyAny
cd AnyAny
cmake . -B build
cmake --build buildgit clone https://github.com/kelbon/AnyAny
cd AnyAny/examples
cmake . -B build
