C++ 带钥匙的纵坐标集装箱

我在寻找一个容器，它基本上是一个列表，其中每个节点由一个元素和元素本身的函数（）组成，其中x和f（x）是整数

这个容器应该允许我以有序的方式插入f（x）提供的订单。 STL里有类似的东西吗？

我想你可以

int foo(int x );

struct mycustomcompare {
  bool operator() (const int& lhs, const int& rhs) const
  {return foo(lhs) < foo(rhs);}
};


int main()
{
    std::set<int,mycustomcompare> myset;
    myset.insert( 1 );
    myset.insert( 2 );
}

intfoo（intx）；
结构mycustomcompare{
布尔运算符（）
{返回foo（lhs）

当然，如果foo（2）和foo（3）返回相同的值，则只会插入其中一个。如果域有问题，可以使用multiset

int foo(int x )
{
    return x % 2 ==0;
}

struct mycustomcompare {
  bool operator() (const int& lhs, const int& rhs) const
  {return foo(lhs) < foo(rhs);}
};


int main()
{
    std::multiset<int,mycustomcompare> myset;
    myset.insert( 1 );
    myset.insert( 2 );
    myset.insert( 3);
    myset.insert( 4);
    myset.insert( 5);
    myset.insert( 6);

}

intfoo（intx）
{
返回x%2==0；
}
结构mycustomcompare{
布尔运算符（）
{返回foo（lhs）

在上述示例中，所有奇数元素都将位于集合的前半部分。或者，您可以简单地使用向量并使用比较函数进行排序

int foo(int x )
{
    return x % 2 ==0;
}

struct mycustomcompare 
{
    bool operator() (const int& lhs, const int& rhs) const
    {return foo(lhs) < foo(rhs);}
};


int main()
{

    std::vector<int> myvector;

    myvector.push_back( 5);
    myvector.push_back( 1 );
    myvector.push_back( 6);
    myvector.push_back( 2 );
    myvector.push_back( 3);
    myvector.push_back( 4);

    std::sort( myvector.begin() , myvector.end() , mycustomcompare() );
}

intfoo（intx）
{
返回x%2==0；
}
结构mycustomcompare
{
布尔运算符（）
{返回foo（lhs）

如果对f（x）的求值很昂贵，您还可以向比较对象添加一些状态。

您可以使用，并使用

f（x）

作为键

#include <map>

int f(int);

int n = ....;
std::map<int,int> m;
m.insert(std::make_pair(f(n), n));

int i = ...;
m[f(i)] = i;

#包括
int f（int）；
int n=。。。。；
std：：map m；
m、 插入（std：：使成对（f（n），n））；
int i=。。。；
m[f（i）]=i；

---

另一种选择是使用合适的比较器功能，正如其他答案中所建议的那样。但是，您必须确保比较器实现，这取决于函数的特性

f（int）

此时，有两种不同的答案建议使用带有自定义比较器的

std:：set

，以及将

f（x）

映射到

x

的

std:：map

。实际上，我会选择第三个选项：

std:：set

，其中pair是

（f（x），x）

与

std:：map

相比，它的优势在于，虽然它持有相同的信息，但它确保

x

不被修改，从而保证在map上迭代始终会产生

（f（x），x）

对的不变量。与

std:：set

相比，当

cmp

为

f

时，函数只需计算一次，且值存在于容器中（这可能会产生影响，也可能不会产生影响，取决于

f

的成本），此外

这种方法与其他方法（可能是正的或负的）的另一个区别是，它自然允许多个

x

值映射到相同的

f（x）

，因为

std:：pair

上的顺序是字典式的，所以容器将按照

f（x）首先确定的顺序存储所有这样的对

，然后通过

x

，对于那些

x

值相同的

f（x）

（即

（0,1）、（0,3）、（1,2）

，假设

f（1）==f（3）==0

和

f（2）==1

---

如果您不能允许这样的重复（即，如果您只希望每个

f（x）

值有一个元素），那么您可以添加一个自定义比较器，只测试每对的

第一个

值。

感谢所有的答案，无论如何，对于不同的x值，我可以得到相同的f（x）值。