标签: std-pair

我正在尝试学习C++,现在我正在编写一个需要输出整数对列表的程序.

处理这个问题的最佳方法是什么？我在学校的linux电脑上没有可用的升级库,所以我不相信我可以使用boost :: tuple.

有什么建议？

我有一个偶数大小的向量，我想将其转换为成对的向量，其中每对始终包含两个元素。我知道我可以使用简单的循环来做到这一点，但我想知道是否有一个很好的标准库工具可以做到这一点？可以假设原始向量始终包含偶数个元素。

例子：

vector<int> origin {1, 2, 3, 4, 5, 6, 7, 8};

vector<pair<int, int>> goal { {1, 2}, {3, 4}, {5, 6}, {7, 8} };

我想将一些数据输出到文件中.例如假设我有两个双打向量:

vector<double> data1(10);
vector<double> data2(10); 

是否有一种简单的方法将其输出到文件,以便第一行包含标题'data1'和'data2',后跟实际内容.输出数据的函数将传递各种不同的数组,因此不可能硬编码标题的名称 - 理想情况下,我想将变量名称转换为某个字符串,然后输出该字符串,后跟向量数组的内容.但是,我不确定如何将变量名'data1'转换为字符串,或者确实如果它可以很容易地完成(从阅读论坛我的猜测是不可以)如果这是不可能的替代可能是使用关联容器(如map)或更简单的"对"容器.

pair<vector<double>,string> data1(10,'data1');  

欢迎大家提出意见!

我想做类似以下的事情:

//std::vector<std::pair<TypeA, TypeB>> someInitializingFunction();
{
  TypeA a;
  TypeB b;

  for (std::tie(a, b) : someInitializingFunction()) {
    // do stuff;
  }
}

但是,这不是有效的代码,因为正如标准所说,基于for循环的范围被定义为等效于:

{
  auto && __range = range-init;
  for ( auto __begin = begin-expr,
      __end = end-expr;
      __begin != __end;
      ++__begin ) {
    for-range-declaration = *__begin;
    statement
  }
}

其中for-range-declaration定义为:

for-range-declaration:attribute-specifier-seq_ {opt} decl-specifier-seq声明符

那么阻碍我的是decl-specifier-seq没有标记为可选的？

因此,似乎我必须依靠旧式的循环来实现这个问题:

std::vector<std::pair<TypeA, TypeB>> myList = someInitializingFunction();

{
  TypeA a;
  TypeB b;

  for (auto it = myList.begin(); it != myList.end(); ++it) {
    std::tie(a, b) = *it;
    // do …

可能重复:
使用带有两个字段和一对的结构有什么区别？

亲爱的大家,

关于对和结构,我有一个小问题.使用std :: pair而不是带有两个单元格的结构有什么好处吗？我已经使用了一段时间,但主要的问题是可读性:如果你想表示例如一个双重(int"标签",双"值")你可以使用a:

typedef std::pair<int,double> myElem;

或者a

typedef struct {
    int label;
    double value;
} myElem;

如果你的语句具有"语义"意义,那么代码就会变得更具可读性(你将永远知道x.label是什么.这与x.first不同).

但是,我猜使用pair有一个优势.它更高效还是其他什么？

以下代码不会在gcc 4.8.2上编译.问题是此代码将尝试复制构造,std::pair<int, A>这是由于struct A缺少复制和移动构造函数而无法发生的.

gcc在这里失败了还是我错过了什么？

#include <map>
struct A
{
  int bla;
  A(int blub):bla(blub){}
  A(A&&) = delete;
  A(const A&) = delete;
  A& operator=(A&&) = delete;
  A& operator=(const A&) = delete;
};
int main()
{
  std::map<int, A> map;
  map.emplace(1, 2); // doesn't work
  map.emplace(std::piecewise_construct,
          std::forward_as_tuple(1),
          std::forward_as_tuple(2)
  ); // works like a charm
  return 0;
}

std::array<std::pair<int, int>, 2> ids = { { 0, 1 }, { 1, 2 } };

VS2013错误:

错误C2440:'初始化':无法从'int'转换为'std :: pair'没有构造函数可以采用源类型,或构造函数重载解析是不明确的

我究竟做错了什么？

例如,使用元组:

#include <tuple>        // std::tuple, std::make_tuple, std::tie

int num;
char letter;
std::tuple<int,char> num_letter;

num_letter = std::make_tuple(10, 'a');
std::tie(num, letter) = num_letter;  // unpack num_letter into num and letter

有没有相当于对的东西？

// ...
num_letter = std::make_pair(10, 'a');
std::pair_tie(num, letter) = num_letter;

我正在尝试将对存储在优先级队列中,并且我使用比较函数来比较每对的第二个值.

#include<iostream>
#include<queue>
#include<utility>
using namespace std;

class CompareDist
{
public:
    bool operator()(pair<int,int> n1,pair<int,int> n2) {
        return n1.second>n2.second;
    }
};
int main()
{
    priority_queue<pair<int,int>,CompareDist> pq;
}

当我编译这个时,我得到一个错误

error: no type named ‘value_type’ in ‘class CompareDist’

可能是什么原因.我是STL的新手.

假设你想利用移动语义,但你的一个可移动类需要成为一部分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？或者我的编译器是否已过时？