如何在 C++ 中按值传递引用？

Question

我正在尝试在 C++ 中创建不可变类型（类），

我这样做是为了使所有方法“又名成员函数”不会修改对象并返回一个新实例。

我遇到了很多问题，但它们都围绕着 C++ 中的引用类型。

一个例子是当通过引用传递相同类类型的参数时：

Imm Imm::someOp( const Imm& p_im ) const
{
   ...
   p_im = p_im.someOtherOp(); //error, p_im is const, can't modify it!
   ...
}

错误是由于通过引用传递值而引起的。 相反，如果我按值传递引用，那么上面的错误行就不会是错误！

考虑一个 Java/C# 示例

class Imm
{
    ...
    Imm someOp( Imm p_im )
    {
        ....
        p_im = p_im.someOtherOp(); //ok, you're not modifying the 
                 //original object, just changing the local reference
        ....  
    }
    ....
}

我怎样才能在 C++ 中做这样的事情？ 我知道我可以使用指针，但后来我遇到了整个内存管理混乱。 我不想担心谁拥有对象的引用。

理想情况下，我想将类设计得像 python 中的不可变字符串； 您可以使用它们，而无需注意甚至不知道它们是不可变的，并且它们的行为就像您所期望的那样； 他们只是工作。

编辑

当然，我可以通过按值传递或使用临时变量（这就是我当前正在做的事情）来解决它。 我要问的是“如何在 C++ 中按值传递引用”

我希望答案围绕 STL 中的某些内容，我目前正在研究 smart_ptr 系列模板。

更新

感谢您的回复，我意识到指针是无法逃脱的。 （请参阅我的其他问题，这实际上是这个问题的后续问题）

Answer 1

在 Java 和 C# 中，您实际上并不是在处理引用 - 它们更像是句柄或指针。 C++ 中的引用实际上是原始对象的另一个名称，而不是指向它的指针（尽管它可以用指针实现）。 当您将值分配给引用时，您正在分配给对象本身。 令人困惑的是，要初始化引用，您可以使用 = 字符，但它是初始化，而不是赋值。

 Imm im, im2, im3; 
 Imm &imr = im;  // initialize a reference to im
 imr = im2; // assign im2 to imr (changes the value of im as well)
 Imm *imp = &im; // initialize a pointer to the address of im
 imp = &im3; // assign the address of im3 to imp (im is unnaffected);
 (*imp) = im2; // assign im2 to imp (modifies im3 as well).

如果您特别想传递“按值引用”，那么您实际上是在寻求术语上的矛盾。 根据定义，引用是通过引用传递的。 正如其他地方所指出的，您可以按值传递指针，也可以直接传递值。 如果您确实愿意，您可以保留类中的引用并按值传递它：

 struct ImmRef
 {
     Imm &Ref;
     ImmRef(Imm &ref) : Ref(ref) {}
 };

另请注意，应用于引用的 const 使引用的对象成为常量，而不是引用。 引用始终是 const。

Answer 2

根据定义，赋值不是一个常量操作吗？

您看起来像是在尝试将某些内容分配给 const 引用，这完全违背了 const 引用的想法。

我认为您可能正在寻找指针而不是引用。

Answer 3

它不像 C++ 那样工作。

当你传递一个对象的引用时，你实际上传递的是该对象在内存中的地址。 引用也不能重新定位到其他对象，因此 C++ 谚语“引用就是对象”。 您必须复制一份才能修改它。 Java 会在幕后为您完成此操作。 C++，你只需复制它即可。

Answer 4

你没有忘记将你调用的方法设置为const吗？

编辑：所以，const 固定。

也许您应该执行类似“

Imm & tmp = p_im.someOtherOp();

然后对 tmp 变量进行进一步操作”的操作。

如果将变量或参数设置为 const & 你只是不能分配给它。

Answer 5

检查此内容以了解临时生命周期 http://herbsutter.wordpress.com/2008/01/01/gotw-88-a-candidate-for-the-most-important-const/

Imm Imm::someOp( const Imm& p_im ) const
{
   ...
   //Imm& im = p_im.someOtherOp();       // will *not* work
   const Imm& im = p_im.someOtherOp();   // will work, but you get a const reference
   ...
}

但是你可以使用 boost::shared_ptr

shared_ptr<Imm> Imm::someOtherOp() const
{
  shared_ptr<Imm> ret = new Imm;
  ...
  return ret;
}

shared_ptr<Imm> Imm::someOp(const share_ptr<Imm>& p_im) const
{
  shared_ptr<Imm> im = p_im->someOtherOp();
}

Answer 6

您需要为传入的参数制作一个新副本。 您可以通过几种等效的方式执行您想要的操作：1）您可以按值传递：

Imm Imm::someOp( Imm im ) const {
   im = im.someOtherOp();      // local im is a copy, original im not modified
   return im;                  // return by value (another copy)
}

或2）您可以按引用传递并显式制作副本：

Imm Imm::someOp( const Imm & im ) const {
   Imm tmp = im.someOtherOp(); // local tmp is a copy
   return tmp;                 // return by value (another copy)
}

两种形式是等效的。

Answer 7

C++ 有比不可变类型更好的东西——const。 根据您的需要，单一类型可以是可变的或不可变的。 也就是说，有一些有用的模式来处理短生命周期（近）副本：

void f(const X &x) {
  // Trivial case: unconditional copy
  X x2=transform(x);
  // Less trivial: conditional copy
  std::optional<X> maybe;
  const X &use=need_copy ? maybe.emplace(transform(x)) : x;
  use.go();  // whichever, x or *maybe
}  // *maybe destroyed iff created, then x2 destroyed

std::unique_ptr 可以在 C++17 之前以类似的方式使用，尽管该函数可以当然抛出std::bad_alloc。