元组的一个元素可以引用另一个吗？

Question

更新:请参阅下面的完整答案.简短的回答是不,不是直接的.您可以使用std::reference_wrapper指针创建间接引用或更一般地使用指针创建相同的效果(但没有语法糖和附加的引用安全性).

我问,因为元组在C++ 11中构成了一个方便的可变存储单元.从理论上讲,元组的一个元素保持对同一元组中另一个元素的引用听起来是合理的.(用"指针"替换"引用",它在实践中起作用.)魔鬼是构造这样一个元组的细节.请考虑以下示例:

#include <tuple>
#include <iostream>

class A
{
public:
  A() : val(42) { }
  int val;
};

class B
{
public:
  B(A &a) : _a(a) { }
  int val() { return _a.val; }

private:
  A &_a;
};

int main()
{
  A a;
  B b(a);
  std::tuple<A, B> t1(a, b);
  a.val = 24;
  std::cout << std::get<0>(t1).val << "\n"; // 42
  std::cout << std::get<1>(t1).val() << "\n"; // 24

  return 0;
}

元组中的第二个元素t1引用自动变量a而不是第一个元素t1.有没有办法构造一个元组,以便元组的一个元素可以保存对同一元组中另一个元素的引用？我知道你可以通过创建一个引用元组来实现这个结果,如下所示:

int main()
{
  A a;
  B b(a);
  std::tuple<A &, B &> t2 = std::tie(a, b);
  a.val = 24;
  std::cout << std::get<0>(t2).val << "\n"; // 24
  std::cout << std::get<1>(t2).val() << "\n"; // 24

  return 0;
}

但是为了我的目的,这是作弊,因为第二个元素t2仍然最终引用一个生活在元组之外的对象.我能想到的唯一方法是编译好但可能包含未定义的行为[编辑以反映Howard Hinnant提供的更简洁的示例]:

int main()
{
    std::tuple<A, B> t3( A(), B(std::get<0>(t3)) ); // undefined behavior?
    std::get<0>(t3).val = 24;
    std::cout << std::get<0>(t3).val << "\n";
    std::cout << std::get<1>(t3).val() << "\n"; // nasal demons?
}

编辑:这是一个最小的测试程序,当使用带有-O2或更高版本的g ++ 4.7进行编译时返回非零退出状态.这表明未定义的行为或gcc中的错误.

#include <tuple>

class Level1
{
public:
  Level1() : _touched(false), _val(0) { }

  void touch()
  {
    _touched = true;
  }

  double feel()
  {
    if ( _touched )
    {
      _touched = false;
      _val = 42;
    }
    return _val;
  }

private:
  bool _touched;
  double _val;
};

class Level2
{
public:
  Level2(Level1 &level1) : _level1(level1) { }

  double feel()
  {
    return _level1.feel();
  }

private:
  int _spaceholder1;
  double _spaceholder2;
  Level1 &_level1;
};

class Level3
{
public:
  Level3(Level2 &level2) : _level2(level2) { }

  double feel()
  {
    return _level2.feel();
  }

private:
  Level2 &_level2;
};

int main()
{
  std::tuple<Level3, Level2, Level1> levels(
    Level3(std::get<1>(levels)),
    Level2(std::get<2>(levels)),
    Level1()
  );

  std::get<2>(levels).touch();

  return ! ( std::get<0>(levels).feel() > 0 );
}

Answer 1

这对我有用:

#include <tuple>
#include <iostream>

int main()
{
    std::tuple<int&, int> t(std::get<1>(t), 2);
    std::cout << std::get<0>(t) << '\n';
    std::get<1>(t) = 3;
    std::cout << std::get<0>(t) << '\n';
}

更新

我刚刚在CWG邮件列表上询问了这个案例.Mike Miller向我保证,这是 3.8p6子弹2的未定义行为:

...如果出现以下情况,该程序的行为不明

...

• glvalue用于访问非静态数据成员或调用对象的非静态成员函数,或

...

如果tuple是聚合,那将是明确定义的行为,但因为tuple有一个用户声明的构造函数,3.8p6b2适用.

然而,这有效,并避免UB:

#include <tuple>
#include <functional>
#include <cassert>

int main()
{
    int dummy;
    std::tuple<std::reference_wrapper<int>, int> t(dummy, 2);
    std::get<0>(t) = std::get<1>(t);
    assert(std::get<0>(t) == 2);
    std::get<1>(t) = 3;
    assert(std::get<0>(t) == 3);
}