Question

假设我有一个基本类Object，它有一些int和std::string s（所以不是很大）。

现在，我需要某种不会改变的Object列表，但我仍然可以搜索它（例如使用函数）。这个＆＃34;列表＆＃34;仅在编译时创建，它将具有约。 60个物体。我目前有两个解决方案：

创建一个具有Objects的类std::vector<Object>，并在构造函数中初始化（以及搜索功能）。
创建一个名称空间，其中包含Objects作为常量，std::vector<Object>用于搜索（等）函数（将在命名空间中定义）。

1的一个缺点是每次我需要访问它们时都必须创建60多个对象。 2可能没问题，但是不要忘记将新对象放到std::vector以及顶部＆＃34;列表＆＃34;。

1可能会像这样实现：

class Objects
{
public:
    Objects()
    {
        list.push_back(Object{ 0 });
        list.push_back(Object{ 1 });
    };

    bool hasValue(int value)
    {
        for (auto& obj: list)
        {
            if (obj.getValue() == value)
                return true;
        }

        return false;
    }

private:
    std::vector<Object> list;
};

2喜欢这样：

namespace Objects
{
    const Object obj1{ 0 };
    const Object obj2{ 1 };

    const std::vector<Object> list{ obj1, obj2 };

    bool hasValue(int value)
    {
        for (auto& obj: list)
        {
            if (obj.getValue() == value)
                return true;
        }

        return false;
    }
}

在编码实践和/或可用性/可维护性方面哪种方式最好？也许还有另一种我没想过的方式？

Answer 1

20个永不改变且需要始终可用的对象？

听起来像是一个返回对静态数组的引用的函数的作业。所有标准算法（在本例中为find_if）都适用于std::array。

#include <iostream>
#include <array>

struct Object
{
    Object(int i) : _i(i) {};

    int _i;
};

const std::array<Object, 20>& objects()
{
    static std::array<Object, 20> os = {
        Object(1),
        Object(2),
        Object(3),
        Object(4),
        Object(5),
        Object(6),
        Object(7),
        Object(8),
        Object(9),
        Object(10),
        Object(11),
        Object(12),
        Object(13),
        Object(14),
        Object(15),
        Object(16),
        Object(17),
        Object(18),
        Object(19),
        Object(20)
    };
    return os;
}


int main()
{
    using namespace std;
    auto const& os = objects();
    auto i_ten = std::find_if(std::begin(os), 
                              std::end(os), 
                              [](auto const& o) { 
                                  return o._i == 10; });

    cout << i_ten->_i << std::endl;

    return 0;
}

实现常量对象列表

1 个答案: