1

在重组一些代码时，我在返回具有 2 个值的结构时遇到了一个“问题”。现在这些确实应该以记录的效果命名。后来我想使用tie，所以我将结构更改为继承std::pair并设置引用。现在这实际上工作正常，但您会注意到现在我的结构的大小为 24，而不是与这对相比只有 8。

#include <tuple>


struct Transaction : public std::pair<int, int> {
    using pair::pair;

  int& deducted = first;
  int& transfered = second;
};
//static_assert(sizeof(Transaction) == sizeof(std::pair<int, int>));//commenting in this line will fail compilation

Transaction makeTheTransaction();

void test(int& deduct, int& transfer) {
    std::tie(deduct, transfer) = makeTheTransaction(); 
}

可能显而易见的方法是更改​​为成员函数，但是对于这种情况来说，这也是太多的“样板”（然后它会变得更容易，tie以后不使用）。直接的 memcpy 是例如。一个元组是直前 UB。直接结构化绑定也不可行，因为变量已经在使用中。

我的问题是，不考虑可重用部分（并且考虑到大小不应超过 2 个整数），有什么更好或最少的代码解决方案？

更新：对于这种情况，我最终只是做了一个简单的结构并暂时保留返回。对于来到这里的其他用户，有一个库提案来提升似乎能够将任何结构转换为元组：https ://github.com/apolukhin/magic_get/

4

3 回答 3

1

看来你对我来说问题过于复杂了。如果你需要使用std::tie，你可以使用它。无需更改您的结构：

struct Transaction
{
  int deducted;
  int transferred;
};

// later...

auto t = std::tie(transaction.deducted, transaction.transferred);

如果这是您经常使用的模式，那么您可以将其包装在一个小辅助方法中：

struct Transaction
{
  int deducted;
  int transferred;

  auto to_tuple() const
  {
    return std::tie(deducted, transferred);
  }
};

您也可以使用它一次分配给多个变量，尽管我强烈反对这样做。它容易出错并导致代码脆弱。（例如，如果你在下面的例子中颠倒了deduct和的顺序transfer，你就有了一个错误，但编译器不会给出警告或错误。）

void test(int& deduct, int& transfer)
{
  std::tie(deduct, transfer) = makeTheTransaction().to_tuple();
}

编辑：再三考虑...

如果这里的目标只是简单地将结构分解为变量，您可以直接这样做并避免使用对或元组：

struct Transaction
{
  int deducted;
  int transferred;

  void decompose(int* deducted_, int* transferred_)
  {
    *deducted_ = deducted;
    *transferred_ = transferred;
  }
};

void test(int& deduct, int& transfer)
{
  makeTheTransaction().decompose(&deduct, &transfer);
}

这仍然很脆弱，但至少现在您在编写对decompose方法的调用时会获得智能感知，这将使模式不太容易出错。

于 2018-11-20T19:46:34.113 回答
0

我会简单地选择：

struct Transaction
{
    int deducted;
    int transfered;
};

用法类似于：

Transaction makeTheTransaction() { return {4, 2}; }

int main()
{
    auto [deduct, transfer] = makeTheTransaction(); 
    std::cout << deduct << transfer << std::endl;
}

演示

于 2018-11-20T19:29:17.717 回答
0

添加转换函数有效：

#include <tuple>

struct Transaction {
    std::pair<int, int> data_;

    operator std::tuple<int &, int &> () {
        return std::tie(data_.first, data_.second);
    }
};
static_assert(sizeof(Transaction) == sizeof(std::pair<int, int>));

Transaction makeTheTransaction() {
    return Transaction();
}

void test(int& deduct, int& transfer) {
    std::tie(deduct, transfer) = makeTheTransaction();
}

我认为与 std::tie 一起使用时不会导致任何生命周期问题。

这Transaction不适用于具有两个标识符的结构化绑定。但是您可以通过专门化std::get和std::tuple_sizefor 来使其支持“类元组”绑定。

于 2018-11-20T19:47:54.833 回答