Question

我有一对对。我想在这个数组上使用memset来生成0,1或-1。我该怎么做？这是我们一直做的正常程序吗？

对和数组是：

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

Answer 1

不要在POD类型的任何内容上使用memset（std::pair不是） - 它不会很顺利（这是不明确的行为）

具有构造函数的类需要调用那些构造函数 - memset不会这样做。具有非POD数据成员的类需要这些成员的构造函数 - memset不会这样做。

对于小型数组，您可以使用aggregate initialization代替。对于更大的阵列，您可以使用循环。而且还有std::fill。

我还建议在编译时知道大小时使用std::array而不是C样式数组 - 否则为std::vector。

Answer 2

如上所述，一对不是POD。

然而，数据可以重组为POD，几乎没有效用：

#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));
}

另一种（可以说是更强大的）方法是发明一个具有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

C ++方式是使用std::fill代替memset，例如：

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

memset c ++中的一对数组

3 个答案: