Question

我有一个向量，其中包含不同组的数据。如果我将特定组的新数据插入向量中，则应使用相同组号的新数据替换旧数据。对于此特定示例，std :: replace给出错误

std :: replace：找不到匹配的重载函数

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

class data
{
    public:
        int group;
        bool condition;
        friend bool operator==(const data& lhs, const data& rhs);
        data(int g, bool c) 
        {
            group = g;
            condition = c;
        }
};

bool  operator==(const data& lhs, const data& rhs)
{
     return lhs.group == rhs.group;
}

int main()
{
    data info_1(1, true);
    data info_2(2, true);
    data info_3(3, false);
    data info_4(4, false);
    data info_5(3, false); 

    std::vector<data> data_vector;

    data_vector.push_back(info_1);
    data_vector.push_back(info_2);
    data_vector.push_back(info_3);
    data_vector.push_back(info_4);

    if (std::find(data_vector.begin(), data_vector.end(), info_5) != data_vector.end())
    {
        std::cout << " Matched: \n";
        std::replace(data_vector.begin(), data_vector.end(), data_vector, info_5);
    }
    else
    {
        std::cout << "Not Matched: \n";
    }

    system("pause");

    return 0;
}

Answer 1

这是代码的修改版本。您应该使用迭代器来获取find（）返回的内容，如果有效，则将其传递给replace（）-

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

class data
{
    public:
        int group;
        bool condition;
        friend bool operator==(const data& lhs, const data& rhs);
        data(int g, bool c) 
        {
            group = g;
            condition = c;
        }
};

bool  operator==(const data& lhs, const data& rhs)
{
     return lhs.group == rhs.group;
}

int main()
{
    data info_1(1, true);
    data info_2(2, true);
    data info_3(3, false);
    data info_4(4, false);
    data info_5(3, false); 

    std::vector<data> data_vector;

    data_vector.push_back(info_1);
    data_vector.push_back(info_2);
    data_vector.push_back(info_3);
    data_vector.push_back(info_4);

    std::vector<data>::iterator it = std::find(data_vector.begin(), data_vector.end(), info_5);

    if ( it != data_vector.end())
    {
        std::cout << " Matched: " << info_5.group << std::endl;
        std::replace(data_vector.begin(), data_vector.end(), *it, info_5);
    }
    else
    {
        std::cout << "Not Matched: \n";
    }

    system("pause");

    return 0;
}

Answer 2

您对此太想了。 std::replace正是您想要的：

std::replace(data_vector.begin(), data_vector.end(), info_5, info_5);

这看起来有点奇怪，因为它用info_5替换了info_5，但是那是因为operator==对于这种类型有点奇怪-它只查看组值，所以它将找到info_3的副本并将其替换为info_5。

现在，这可能有点过头了，因为它将查找向量中每次出现的info_5并将其全部替换。在许多情况下，只有一个匹配值。您可以使用std::find来找到它，然后只需分配一个新值：

auto iter = std::find(data_vector.begin(), data_vector.end(), info_5);
if (iter != data_vector.end())
    *iter = replacement_value;

另一方面，如果您确实只希望每个组一个条目，那么使用std::map可能会更好。要替换与组关联的值，只需查找该组并分配给它即可。对于具有data_map类型的名为std::map<int, bool>的对象，并为其分配了值，您要做的就是：

data_map[3] = false;

但是，如果没有条目（每组3个），则会添加一个。如果那不是您想要的，则必须首先检查：

auto iter = data_map.find(3);
if (iter != data_map.end())
    *iter = replacement_value;

Answer 3

我建议您出于目的使用std::map。

#include <iostream>
#include <map>
#include <algorithm>

void insert_or_assign (std::map<int, bool> &data, const std::pair <int, bool> item){
    auto search = data.find(item.first);
    if(search != data.end()) {
        data.erase(search);
    }
    data.insert(item);
}

int main() {
    std::map<int, bool> data;

    data.insert(std::pair <int, bool> (1, true));
    data.insert(std::pair <int, bool> (2, true));
    data.insert(std::pair <int, bool> (3, true));
    data.insert(std::pair <int, bool> (4, false));
    data.insert(std::pair <int, bool> (5, false));

     insert_or_assign(data, std::pair <int, bool> (5, true));
     insert_or_assign(data, std::pair <int, bool> (6, true));

    for (const auto &item : data) {
       std::cout << item.first << " " <<item.second << "\n";
    }
}

这给出了输出

如果您使用的是c ++ 17编译器，则可以直接使用std::map::insert_or_assign

通过值查找和替换向量中的元素

3 个答案: