C++ 最佳C&x2B+；存储独特元素的方法

我画了一幅图来描述我正在寻找的数据结构

什么是最有效的C++方式声明这种数据结构，其中：

尺寸在第一维是固定的，在第二维是动态的。在第二个维度中，在插入元素时，其大小会动态增加

每个列（图中）只允许使用唯一的元素。顺序并不重要

---

我探索了

std:：set

和

setarray

的用法。但是解决方案能否包括如何声明、初始化和访问数据结构

类似的事

int main()
{
    const unsigned int FIXED_SIZE=10;
    std::array<std::set<int>, FIXED_SIZE> data;

    data[1].insert(4);
    data[2].insert(100);
    data[2].insert(200);

    // Calculation:
    for( auto a : data )
    {
        int mw=0;

        for ( auto s: a )
        {
            mw+=s;
        }
        if ( a.size() )
        {
            mw/=a.size();

            std::cout << "MW in class is " << mw << std::endl;
        }
        else
        {
            std::cout << "class was empty" << std::endl;
        }
    }
};

intmain（）
{
常量无符号整数固定大小=10；
std：：数组数据；
数据[1]。插入（4）；
数据[2]。插入（100）；
数据[2]。插入（200）；
//计算：
用于（自动a：数据）
{
int mw=0；
用于（自动s:a）
{
mw+=s；
}
如果（a.size（））
{
mw/=a.尺寸（）；
std:：cout下面是一个如何创建和使用这种结构的示例

// Example program
#include <algorithm>
#include <array>
#include <iostream>
#include <set>

int main()
{
    std::array<std::set<double>, 4> bins = {std::set<double>{1.0, 2.0, 5.0},
                                            std::set<double>{7.0, 2.0},
                                            std::set<double>{3.0, 9.0 ,1.0},
                                            std::set<double>{7.0, 0.0, 1.0, 4.0}};
    bins[1].insert(3);

    for (auto const& bin : bins)
    {
        std::cout << "average: " << std::accumulate(bin.begin(), bin.end(), 0.0) / bin.size();
        std::cout << "\tvalues : ";
        for (auto const& value : bin) std::cout << value << " ";
        std::cout << std::endl;
    }
}

编辑：

如果您没有访问C++11的权限，您可以使用
向量
而不是
数组
，但要知道它的大小不是固定的。您也不能使用
自动
。因此，您可以将代码更改为

#include <algorithm>
#include <vector>
#include <iostream>
#include <set>

int main()
{
    std::vector<std::set<double>> bins = {{1.0, 2.0, 5.0},
                                          {7.0, 2.0},
                                          {3.0, 9.0, 1.0},
                                          {7.0, 0.0, 1.0, 4.0}};
    bins[1].insert(3);

    for (std::vector<std::set<double>>::iterator itBin = bins.begin()
         itBin != bins.end();
         ++itBin)
    {
        std::set<double> const& bin = *itBin;
        std::cout << "average: " << std::accumulate(bin.begin(), bin.end(), 0.0) / bin.size();
        std::cout << "\tvalues : ";
        for (std::set<double>::iterator itValue = bin.begin();
             itValue != bin.end();
             ++itValue)
        std::cout << *itValue << " ";
        std::cout << std::endl;
    }
}

#包括
#包括
#包括
#包括
int main（）
{
std:：vector bin={{1.0,2.0,5.0}，
{7.0, 2.0},
{3.0, 9.0, 1.0},
{7.0, 0.0, 1.0, 4.0}};
垃圾箱[1]。插入（3）；
对于（std:：vector:：iterator itBin=bins.begin（）
itBin！=bins.end（）；
++itBin）
{
std:：set const&bin=*itBin；
std:：cout仅适用于C++11，考虑到顺序无关紧要，并假设第一个维度的“固定大小”仅在运行时已知：

#include <vector>
#include <unordered_set>

template <class T>
class MyDataStructure
{
public:

    typedef std::unordered_set<T>     column_type;
    typedef std::vector<column_type>  row_type;

    MyDataStructure()
        { clear(); }
    explicit MyDataStructure( size_t n )
        { resize(n); }

    void clear()
        { m_data.clear(); }
    void resize( size_t n )
        { m_data.resize(n); }

    // Number of columns
    inline size_t size() const 
        { return m_data.size(); }

    // Access column k (eg for iteration)
    inline const column_type& column( size_t c ) const { return m_data[c]; }
    inline       column_type& column( size_t c )       { return m_data[c]; }

    // Insert in column k
    inline void insert( size_t c, const T& val ) 
        { column(c).insert(val); }
    inline void insert( size_t c, T&& val ) 
        { column(c).emplace(std::forward<T>(val)); }

private:
    row_type m_data;
};

#包括
#包括
模板
类MyDataStructure
{
公众：
typedef std:：无序设置列类型；
typedef std:：向量行\ u类型；
MyDataStructure（）
{clear（）；}
显式MyDataStructure（大小\u t n）
{调整大小（n）；}
无效清除（）
{m_data.clear（）；}
空心调整大小（大小\u t n）
{m_data.resize（n）；}
//列数
内联大小\u t size（）常量
{返回m_data.size（）；}
//访问列k（例如用于迭代）
inline const column_type&column（size_t c）const{return m_data[c]；}
内联列类型和列（大小）{返回m_数据[c]；}
//在k列中插入
内嵌空心插入件（尺寸、常数和值）
{列（c）.插入（val）；}
内嵌空心插入件（尺寸c、t和val）
{column（c）.emplace（std:：forward（val））；}
私人：
行类型m_数据；
};

如果需要，您可以轻松添加成员变量以跟踪元素总数。您还可以轻松实现元素删除（
erase
）和搜索（
find
）如果您想要一个非C++ 11的解决方案，请删除ESPIT插入，并替换为<代码> unordeDeSET/<代码> <代码> SET/COD> .< /P> < P> C++，使用<代码> STD:：：Trase<代码> +>代码> STD:：SET//CUL> 

#include <tr1/array>
#include <set>

int main( )
{
    std::tr1::array< std::set<float>, 7> foo;

    foo[1].insert(1.7F);
    foo[1].insert(2.3F);
    foo[6].insert(9.0F);

    return 0;
}

#include <array>
#include <unordered_set>

int main( )
{
    std::array< std::unordered_set<int>, 3> obj;

    foo[1].insert(1);
    foo[1].insert(2);
    foo[3].insert(1);

    return 0;
}

在我看来像是一个
std:：array
，其中
N
是固定大小的。然后你可以发布一个解决方案，在其中声明、初始化和访问它吗？虽然你有一个固定大小的数组，但我还是会选择
std:：vector
你在优化什么操作？这是散列集，也就是无序集确切地说不确定W元素将被填充，但是如果它们一次被推到一个位置，你可以考虑向这个解决方案添加一个运行平均值，这样你就不必在结束时迭代它们。我只阅读问题作者的评论。虽然有很多改进但没有要求：-这个解决方案很好。我的评论是对OP的一个建议。似乎STL <代码>数组< /C>只是C++的一部分。自2011年以来，你可以使用STD:：vector或STD：：数组BIs（4）还有。问题：auto-const或const-auto。可以吗？@911它们是等效的，您的首选。@911
std:：vector
。
#include <array>
#include <unordered_set>

int main( )
{
    std::array< std::unordered_set<int>, 3> obj;

    foo[1].insert(1);
    foo[1].insert(2);
    foo[3].insert(1);

    return 0;
}