C++ 基于std:：vector的内容动态设置顺序的模式<；字符串>；

我目前正在努力想出一种动态排序的优化方法。我现在有一个向量，在代码的某个地方看起来像这样

std::vector<std::string> vec {
      "optionB",
      "optionA",
      "optionC"
  };

我想到的最简单的方法是

    for(auto str : vec) 
    {
      if( (str=="optionA" && _optionA))
       {
          //This was optionA
       }
       else if( (str=="optionB" && _optionB)) {

       }
       else if( (str=="optionC" && _optionC)) {

       }
   } 

---

我想知道完成上述任务的最佳方式是什么？我正在寻找一种解决方案，可以避免迭代向量，因为它包含在一段以性能为中心的代码中。我有没有办法使用集成位操作或类似数组索引的方法来完成这项任务？如果有不清楚的地方，请告诉我

如果我没有弄错问题，排序是一种方法。只需将向量与

bool

标志一起排序，使用

std:：vector

值作为键，然后简单地按固定的、字典式的顺序检查

bool

标志

假设我们有一个向量

{“optB”，“optC”，“optA”}

。排序后，索引

{0,1,2}

将重新排列：

std:：size\u t perm[]={2,0,1}

。使用这些可以预计算的信息（在

过滤器（…）

之外），我们可以重新排列

bool

标志：

bool options[N];
// populate options...

bool new_options[N];
for (std::size_t i = 0; i < N; ++i)
    new_options[perm[i]] = options[i];

要预计算

perm

数组，请使用

std:：map

：

std::map<std::string, std::size_t> map;
for (std::size_t i = 0; i < N; ++i)
    map.emplace(vec[i], i);

std::size_t perm[N];
auto m = map.begin();
for (std::size_t i = 0; i < N; ++i, ++m)
    perm[i] = m->second;

std:：map；
对于（标准：：大小\u t i=0；is；

听起来像是要将字符串映射到实际进程。您能否创建一个接口选项类，并将选项实例映射到应该导致它们发生的字符串？这样，您就可以使用字符串作为键来获取Option对象并调用类似myOption.execute（）的东西

这种方法的缺点是，每次需要一个新选项时，都需要创建一个新的选项类，并让它从接口继承

---

@编辑：对不起，我想我可能误解了这个问题。但我认为前提仍然适用，你可以有一个字符串到布尔值的映射，只需使用字符串作为键，就可以返回该选项是打开还是关闭。

假设你在启动时加载向量，你可以根据自己的喜好在该点对它进行排序。例如，按字母顺序。这意味着您知道向量的顺序，因此在检查过滤器函数时，您可以简单地按索引引用向量

将数据加载到vector

std:：vector data={“optionA”，“optionB”}

使用

std:：Sort（data.begin，data.end）进行排序

或您选择的任何其他排序方法

然后在过滤函数中根据索引检查向量

if（data.at（1）=“optionA”）{}

---

如果我正确理解您的问题，您需要在布尔变量/谓词上暗示order\u by。
在下面的程序中，我将把（

\u optionA

，

\u optionB

，

\u optionC

）作为谓词，即使它们是

bool

，因为我们也可以将此问题升级为谓词

基于上述假设，我将继续实施

您应该将一个

有序的\u谓词

传递给筛选函数。

ordered_谓词

根据所需的条件进行排序。

filter（）

的工作就是按照定义的顺序执行它们

auto filter(std::vector<bool> const & ordered_predicates)
    -> void
{
    for (auto const & condition : ordered_predicates) {
        if (condition) {
            // ... do your usual stuff here
        }
    }
}

其中，

order\u by\u criteria

是您的

std:：vector

，

mapping

只是一个映射，它告诉您哪些字符串和谓词是相关联的

    std::vector<std::string> order_by_criteria { "optionB", "optionA", "optionC" };

    std::map<std::string, bool> mapping = { {"optionA", _optionA },
                                            {"optionB", _optionB },
                                            {"optionC", _optionC } };

std:：向量顺序{“optionB”、“optionA”、“optionC”}；
映射={{“optionA”，_optionA}，
{“optionB”，_optionB}，
{“optionC”，_optionC}；

这里有一个完整的工作程序供您参考

#include <iostream>
#include <map>
#include <vector>

auto order_by(std::vector<std::string>    const & order_by_criteria,
              std::map<std::string, bool> const & mapping)
    -> std::vector<bool>
{
    std::vector<bool> ordered_predicates;
    for (auto const & item : order_by_criteria)
        ordered_predicates.push_back(mapping.at(item));
    return ordered_predicates;
}

auto filter(std::vector<bool> const & ordered_predicates)
    -> void
{
    for (auto const & condition : ordered_predicates) {
        if (condition) {
            // ... do your usual stuff here
        }
    }
}

int main()
{
    bool _optionA = true, _optionB = false, _optionC = true;

    std::vector<std::string> order_by_criteria { "optionB", "optionA", "optionC" };

    std::map<std::string, bool> mapping = { {"optionA", _optionA },
                                            {"optionB", _optionB },
                                            {"optionC", _optionC } };

    auto ordered_predicates = order_by(order_by_criteria, mapping);

    filter(ordered_predicates);
    filter(ordered_predicates); // call as many times as you want, with pre-decided order 

    return 0;
}

#包括
#包括
#包括
自动按顺序排列（标准：：向量常量和按顺序排列标准，
标准：：映射常量和映射）
->向量
{
std：：向量有序_谓词；
用于（自动施工和项目：按标准订购）
有序的_谓词。向后推_（mapping.at（item））；
返回有序谓词；
}
自动筛选（标准：：向量常量和有序谓词）
->空虚
{
for（自动常量和条件：有序谓词）{
如果（条件）{
//…在这里做你平常的事
}
}
}
int main（）
{
bool _optionA=true，_optionB=false，_optionC=true；
std：：向量顺序{“optionB”、“optionA”、“optionC”}；
映射={{“optionA”，_optionA}，
{“optionB”，_optionB}，
{“optionC”，_optionC}；
自动排序的谓词=order\u by（order\u by\u标准，映射）；
过滤器（有序谓词）；
filter（ordered_谓词）；//按预先确定的顺序调用任意次数
返回0；
}

您希望购买多少件物品？如果它比较小，不是很大。您可以提供一个向量来定义您的自定义订单，并在其他向量中根据您对该订单的查找插入项目。我相信你是在找一个海关官员，我想我不明白这个问题。是否要确定

if

条件的特定顺序（取决于向量中元素的顺序）？类似于

std:：map条件；std：：向量顺序；对于（const auto&elem:order）{if（conditions[elem]）{doSth（）；}}}

？@Ptaq666是的，我可以这样做，但我正在寻找一个甚至优化的解决方案。我想避免iterations@SamerTufail由于性能原因，我希望避免过滤器函数中的向量迭代。如果向量只加载一次，并且没有添加更多的项，那么您可以在加载期间或其他地方对其进行排序，然后只使用数组索引？A

auto order_by(std::vector<std::string>    const & order_by_criteria,
              std::map<std::string, bool> const & mapping)
    -> std::vector<bool>
{
    std::vector<bool> ordered_predicates;
    for (auto const & item : order_by_criteria)
        ordered_predicates.push_back(mapping.at(item));
    return ordered_predicates;
}

    std::vector<std::string> order_by_criteria { "optionB", "optionA", "optionC" };

    std::map<std::string, bool> mapping = { {"optionA", _optionA },
                                            {"optionB", _optionB },
                                            {"optionC", _optionC } };

#include <iostream>
#include <map>
#include <vector>

auto order_by(std::vector<std::string>    const & order_by_criteria,
              std::map<std::string, bool> const & mapping)
    -> std::vector<bool>
{
    std::vector<bool> ordered_predicates;
    for (auto const & item : order_by_criteria)
        ordered_predicates.push_back(mapping.at(item));
    return ordered_predicates;
}

auto filter(std::vector<bool> const & ordered_predicates)
    -> void
{
    for (auto const & condition : ordered_predicates) {
        if (condition) {
            // ... do your usual stuff here
        }
    }
}

int main()
{
    bool _optionA = true, _optionB = false, _optionC = true;

    std::vector<std::string> order_by_criteria { "optionB", "optionA", "optionC" };

    std::map<std::string, bool> mapping = { {"optionA", _optionA },
                                            {"optionB", _optionB },
                                            {"optionC", _optionC } };

    auto ordered_predicates = order_by(order_by_criteria, mapping);

    filter(ordered_predicates);
    filter(ordered_predicates); // call as many times as you want, with pre-decided order 

    return 0;
}