memset un tableau de paires en C++

Question

J'ai un tableau de paires. Je veux utiliser memset sur ce tableau pour faire 0, 1 ou -1. Comment puis-je le faire? Est-ce une procédure normale comme nous le faisons toujours?

La paire et le réseau est:

std::pair<int, int> ar[100][100]; 

Answer 1

Ne pas utiliser memset sur tout ce qui est pas un type POD (qui std::pair est pas) - il ne va pas bien (il est un comportement non défini à faire alors).

Les classes avec des constructeurs ont besoin de ces constructeurs pour être appelés - memset ne fait pas cela. Les classes avec des membres de données non POD ont besoin des constructeurs de ces membres appelés - memset ne fait pas cela.

Pour les petites baies, vous pouvez utiliser aggregate initialization à la place. Pour les tableaux plus grands, vous pouvez utiliser une boucle. Il y a aussi std::fill.

Je recommande également d'utiliser un std::array sur un tableau de type C lorsque la taille est connue au moment de la compilation - ou un std::vector sinon.

Answer 2

Comme mentionné, une paire n'est pas un POD.

Cependant, les données pourraient être restructurées en tant que POD avec peu de perte d'utilité:

#include <tuple> 
#include <utility> 
#include <cstring> 

/* this is a POD */ 
using pair_matrix = int [100][100][2]; 

extern std::tuple<int, int> foo(); 
extern void bar(std::tuple<int&, int&>); 

int main() 
{ 
    pair_matrix m; 

    /* we can memset PODS */ 
    std::memset(std::addressof(m), sizeof(m), 0); 

    /* we can convert the 2-d array into a tuple easily */ 
    auto at = [&m](int x, int y) { 
     auto& a = m[y][x]; 
     return std::tie(a[0], a[1]); 
    }; 

    /* and manipulate as a tuple */ 
    at(10,10) = foo(); 
    bar(at(10,10)); 
} 

Une autre façon (sans doute plus robuste) est d'inventer le concept d'une classe de tableau multidimensionnel qui présente un procédé fill :

#include <tuple> 
#include <utility> 
#include <memory> 

template<class Type, std::size_t...Dimensions> struct dimension_view; 
template<class Type> struct dimension_view<Type> 
{ 
    static constexpr std::size_t extent = 1; 
    static constexpr std::size_t size() { return extent; } 
    static constexpr std::size_t storage_size = 1; 

    using storage_type = Type; 

    constexpr dimension_view(Type* data) : data_(data) {} 

    operator Type&() { return *data_; } 

    template<class Other> 
    constexpr Type& operator=(Other&& other) { 
     *data_ = std::forward<Other>(other); 
     return *data_; 
    } 

    storage_type* data_; 
}; 

template<class Type, std::size_t Dim, std::size_t...Rest> 
struct dimension_view<Type, Dim, Rest...> 
{ 
    using next = dimension_view<Type, Rest...>; 
    static constexpr std::size_t extent = Dim; 
    static constexpr std::size_t size() { return extent; } 
    static constexpr std::size_t storage_size = Dim * next::storage_size; 

    using storage_type = Type [storage_size]; 

    constexpr dimension_view(Type* data) : data_(data) {} 

    auto begin() -> Type* 
    { 
     return data_; 
    } 
    auto end() -> Type* 
    { 
     return std::addressof(data_[extent * next::storage_size]); 
    } 

    auto operator[](std::size_t i) { 
     return next(std::addressof(data_[i * next::storage_size])); 
    } 

    Type* data_ ; 
}; 

template<class T, std::size_t...Dims> 
struct multi_dimensional_array 
{ 
    using view_type = dimension_view<T, Dims...>; 
    using storage_type = typename view_type::storage_type; 

    template<class...Args, std::enable_if_t<std::is_nothrow_constructible<T, Args...>::value>* = nullptr> 
    constexpr multi_dimensional_array(Args&&...args) 
    { 
     for(auto&& store : data_) 
     { 
      new (std::addressof(store)) T (args...); 
     } 
    } 

    template<class...Args, std::enable_if_t<not std::is_nothrow_constructible<T, Args...>::value>* = nullptr> 
    multi_dimensional_array(Args&&...args) 
    { 
     auto count = std::size_t(0); 
     try { 
      for(auto&& store : data_) 
      { 
       new (std::addressof(store)) T (args...); 
       ++count; 
      } 
     } 
     catch(...) { 
      destroy(count); 
     } 
    } 

    /* delete copies for now */ 
    multi_dimensional_array(multi_dimensional_array const&) = delete; 
    multi_dimensional_array& operator=(multi_dimensional_array const&) = delete; 
    multi_dimensional_array(multi_dimensional_array &&) = delete; 
    multi_dimensional_array& operator=(multi_dimensional_array &&) = delete; 

    ~multi_dimensional_array() 
    { 
     destroy(view_type::storage_size); 
    } 

    void destroy(std::size_t last) 
    { 
     while(last--) { 
      reinterpret_cast<T*>(get_data()+last)->~T();  } 
    } 

    constexpr auto begin_storage() { 
     return view_type(get_data()).begin(); 
    } 

    constexpr auto end_storage() { 
     return view_type(get_data()).end(); 
    } 

    constexpr auto fill(T value) -> void 
    { 
     std::fill(begin_storage(), end_storage(), value); 
    } 

    constexpr auto operator[](std::size_t i) -> decltype(auto) { 
     return view_type(get_data())[i]; 
    } 

    constexpr T* get_data() { 
     return reinterpret_cast<T*>(data_); 
    } 

    std::aligned_storage_t<sizeof(T), alignof(T)> data_[view_type::storage_size]; 
}; 

using pair_matrix = multi_dimensional_array<std::pair<int, int>, 100, 100>; 


void force_view(pair_matrix&); 
void force_deref(std::pair<int, int>&); 
std::size_t getval(); 

int main() 
{ 
    /* create with initial values */ 
    pair_matrix m(std::make_pair(-1, 1)); 

    /* fill the entire multidimentional array */ 
    m.fill(std::make_pair(-1, -1)); 

    m[10][10] = std::make_pair(1,1); 

    /* force compiler to generate some code to exercise implementation */ 
    force_view(m); 
    force_deref(m[getval()][getval()]); 
} 

Answer 3

La façon C++ est d'utiliser std::fill au lieu de memset, quelque chose comme:

std::pair<int, int> ar[100][100]; 
std::fill(&ar[0][0], &ar[0][0] + 100 * 100, std::make_pair(-1, -1));