标签: std-pair

假设你想利用移动语义,但你的一个可移动类需要成为一部分std::pair.目的是创建一个函数,该函数返回一个std::pair可被视为右值并转发的函数.

但我无法看到如何做到这一点,除非对其std::pair自身进行内部更改,以使其了解移动语义.

请考虑以下代码:

struct Foo
{
 Foo() { }

 Foo(Foo&& f) { }

 private:

 Foo(const Foo& f) { } // do not allow copying
};

int main() 
{
 Foo f;
 std::pair<Foo, int> res = std::make_pair(f, 10); // fails due to private copy constructor
}

问题是std::make_pair,除了std::pair构造函数本身之外,还需要两个对象并尝试制作它们的内部副本.这导致它尝试并调用复制构造函数.但在我的例子中,我希望能够将新对移动到res,并确保不会制作副本.我认为除非std::pair自己在内部定义了以下构造函数,否则这是不可能的:

pair(T1&& t1, T2&& t2) : first(std::move(t1)), second(std::move(t2))

但它没有,至少在我使用的编译器上没有(gcc 4.3.2).这可能是因为我的编译器是简单地外的日期,而事实上新版本将拥有这一举动感知构造.但是我对移动语义的理解目前有点不稳定,所以我不确定我是否只是在这里忽略了一些东西.那么,我是否正在努力实现,而不是实际重新实现std::pair？或者我的编译器是否已过时？

考虑以下简单示例,我用它std::equal_to来比较两个std::pair<std::string, unsigned>.它operator new被重载,以便在分配时打印一条消息(此处为实时代码):

#include <functional>
#include <string>
#include <iostream>

// overloaded to see when heap allocations take place
void* operator new(std::size_t n)
{
    std::cout << "Allocating " << n << std::endl;
    return malloc(n);
}

int main()
{
    using key_type = std::pair<std::string, unsigned>;
    auto key1 = std::make_pair(std::string("a_______long______string______"), 1);
    auto key2 = std::make_pair(std::string("a_______long______string______"), 1);

    std::cout << "Finished initial allocations\n\n" << std::endl;

    std::equal_to<key_type> eq;
    eq(key1, key2); // how can this cause dynamic allocation???
}

我看到的信息是 …

对不起有点初学者的问题.有矢量和矢量对

typedef std::vector <int> TItems;
typedef std::vector < std::pair <int, int> > TPairs;

有没有办法在一步中将对中的所有第一项转换为另一个向量

int main ()
{
TItems items;
TPairs pairs;

pairs.push_back (std::make_pair(1,3));
pairs.push_back (std::make_pair(5,7));

std::transform( items.begin(), items.end(), items.begin(), comp ( &pairs ) );

return 0;
}

如何设计仿函数？

class comp
{
private:
     TPairs *pairs;

public:
    comp ( TPairs  *pairs_ ) : pairs ( pairs_) { }

    unsigned int operator () ( const unsigned int index ) const
    {
        return  (*pairs)[index].second != pairs->end();  //Bad idea
    }
};

也许有一些没有lambda表达式和循环的用户友好方法.谢谢你的帮助.

我的代码:

 typedef pair<int,int> Pair
  tr1::unordered_map<Pair,bool> h;
  h.insert(make_pair(Pair(0,0),true));

Erorr

 undefined reference to `std::tr1::hash<std::pair<int, int> >::operator()(std::pair<int, int>) const'

我需要修理什么？

谢谢

基于前一个问题,我试图使用一对整数作为关键创建一个映射,即map<pair<int, int>, int>我找到了有关如何插入的信息:

#include <iostream>
#include <map>

using namespace std;

int main ()
{
map<pair<int, int>, int> mymap;

mymap.insert(make_pair(make_pair(1,2), 3)); //edited
}   

但我似乎无法访问该元素!我试过cout << mymap[(1,2)] << endl;但它显示错误,我找不到有关如何使用密钥访问元素的信息.难道我做错了什么？

下面非常简单的代码在C++ 98中编译和链接而没有警告,但在C++ 11模式下给出了一个难以理解的编译错误.

#include <map>

struct A {
    A(A& ); // <-- const missing
};

int main() {
    std::map<int, A> m;
    return m.begin() == m.end(); // line 9
}

错误-std=c++11是,gcc版本4.9.0 20140302(实验)(GCC):

ali@X230:~/tmp$ ~/gcc/install/bin/g++ -std=c++11 cctor.cpp 
In file included from /home/ali/gcc/install/include/c++/4.9.0/bits/stl_algobase.h:64:0,
                 from /home/ali/gcc/install/include/c++/4.9.0/bits/stl_tree.h:61,
                 from /home/ali/gcc/install/include/c++/4.9.0/map:60,
                 from cctor.cpp:1:
/home/ali/gcc/install/include/c++/4.9.0/bits/stl_pair.h: In instantiation of ‘struct std::pair’:
cctor.cpp:9:31:   required from here
/home/ali/gcc/install/include/c++/4.9.0/bits/stl_pair.h:127:17: error: ‘constexpr std::pair::pair(const std::pair&) [with _T1 = const int; _T2 = A]’ declared to take const reference, but implicit declaration would …

我正在尝试将地图复制到对的向量中,因此我可以通过对的second数据成员对向量进行排序.我已经解决了这样做:

void mappedWordsListSorter(){
  for (auto itr = mappedWordsList.begin(); itr != mappedWordsList.end(); ++itr){
    vectorWordsList.push_back(*itr);
  }
  sort(vectorWordsList.begin(), vectorWordsList.end(), [=](pair<string, int>& a, pair<string, int>& b){return a.second > b.second;});
}

我需要找到一种方法来实现这一点而不使用原始循环,而是使用标准库.我通过传递地图的键或值来遇到很多例子.我需要复制到一个矢量pairs<string, int>.最好的方法是什么？

我在玩autoin std::pair。在下面的代码中，函数f应该返回std::pair依赖于模板参数的类型。

一个工作示例：

例 1

template <unsigned S>
auto f()
{
    if constexpr (S == 1)
        return std::pair{1, 2}; // pair of ints
    else if constexpr (S == 2)
        return std::pair{1.0, 2.0}; // pair of doubles
    else
        return std::pair{0.0f, 0.0f}; // pair of floats
}

这适用于 gcc 9.2、gcc 10.0、clang 9.0 和 clang 10.0。

接下来，std::pair为了清楚起见，我想明确地将返回类型写为 a ：

例2

template <unsigned S>
std::pair<auto, auto> f()
{
    if constexpr (S == 1)
        return {1, …

地图插入有两种方式:

m[key] = val;

要么

m.insert(make_pair(key, val));

我的问题是,哪个操作更快？人们通常说第一个较慢,因为如果'key'在map中不存在,STL Standard首先'插入'一个默认元素,然后将'val'分配给默认元素.

但由于'make_pair',我没有看到第二种方式更好.make_pair实际上是一种方便的方式来制作'对' pair<T1, T2>(key, val).无论如何,他们都做了两个任务,一个是将'key'分配给'pair.first',两个分配'val'给'pair.second'.完成配对后,map将插入由'pair.second'初始化的元素.

所以第一种方式是1.' default construct of typeof(val)'2.分配第二种方式是1.赋值2.' copy construct of typeof(val)'

Heyho,

我有一个关于排序对矢量的问题:

std::vector<std::pair<double,Processor*>> baryProc;

这个向量已经填满了对.现在我想根据对中的double值对向量内的对进行排序

例:

假设我在向量内有3对.pair1在前面,第3对在前面.pair2在中间:

pair1(1, proc1) 
pair2(3, proc2)
pair3(2.5, proc3)

现在我想根据double值对对进行排序.这样向量内的顺序是:

pair1(1, proc1) 
pair3(2.5, proc3)
pair2(3, proc2)

我怎么能这样做？我很困惑.

谢谢您的帮助