Question

我正在处理持久性数据结构我需要一个复杂的类来创建一个新实例，但是有一个或多个具有不同值的字段。

struct Data {
  int field1; int field2; int field3; // etc.
public:
  Data withField2(int newField2) {
      return { field1, newField2, field3 };
  }
};

int main()
{
  Data d = { 1, 2, 3 };
  std::cout << d.field2 << std::endl;
  Data newD = d.withField2(4);
  std::cout << newD.field2 << std::endl;
}

最糟糕的情况是，我可以创建一堆withField1(newField1Value)方法，但是会有足够的字段使得它变得非常混乱。
此外，我可能想要多个字段的新值，因此可能还有更多。

那么，是否有一些神奇的说法

Data newData = data.with(field1Name = newField1, field2Name = newField2)

或类似的东西？

Answer 1

你不能这样做，但你可以通过指向数据成员的指针做一些有趣的事情：

_productLoop(){
    let products = this.props.data.map(product => {
      let varient = product.variants.map(v => v);
      console.log(varient[0]);
      return(
        <tr key={product.id}>
          <td>{product.title}</td>
        </tr>
      )
    });
    return(<tbody>{products}</tbody>);
  }


render() {
  return (
    <table>
      [...]
      {this._productLoop()}
    </table>
  )
 }

这样您就不必至少编写所有#include<iostream> #include<functional> struct Data { int field1; int field2; int field3; // etc. template<int Data::*M> Data withField(int value) { Data cpy = *this; cpy.*M = value; return cpy; } }; int main() { Data d = { 1, 2, 3 }; std::cout << d.field2 << std::endl; Data newD = d.withField<&Data::field2>(4); std::cout << newD.field2 << std::endl; }成员方法。

通过一些机器和元编程，也许您还可以定义一个方法来同时更改一堆数据字段。

当然，只要您的字段都是withField类型，这样就可以了否则，您需要多种方法或类似的方法：

int

必须将其调用为：

template<typename T, T Data::*M>
Data withField(T value) {
  Data cpy = *this;
  cpy.*M = value;
  return cpy;
}

Answer 2

问题似乎在于您正在重塑std::tuple。但你并没有重新发明std::get<N>。

您的实现使用名称，对于编译器，它们完全是任意的。不保证字段名称按数字顺序出现而没有喘气。

避免样板在C ++中创建新的不可变实例

2 个答案: