Java 和 C++ 按值传递和按引用传递

Question

据说在Java中方法参数是按值传递的，对于基元和对象来说都是如此，对象的引用是按值传递的。为了说明考虑代码：

class Test {
 private static void dateReplace (Date arg) {
        arg = new Date (arg.getYear(), arg.getMonth(), arg.getDate() +1);
        System.out.println ("arg in dateReplace: " + arg);
    }

 public static void main(String[] args) {

      Date d1 = new Date ("1 Apr 2010");
        dateReplace(d1);
        System.out.println ("d1 after calling dateReplace: " + d1);
    }
}

this will print:
arg in dateReplace: Fri Apr 02 00:00:00 2010
d1 after calling dateReplace: Thu Apr 01 00:00:00 2010.

产生相同结果的 C++ 等价物是什么？

什么是 C++ 等效项，它在调用方法后将 d1 的值与方法内的值相同，即调用者看到修改后的值？

Answer 1

对于值和引用，C++ 的语义与 Java 不同。起初，每种类型都有可能通过复制或引用或地址传递（但是，您可以通过隐藏复制构造函数来防止类型通过复制传递）。

与 Java 的“按引用”传递最密切相关的传递类型是指针。以下是这三者的一个例子：

void foo(std::string bar); // by copy
void foo(std::string& bar); // by reference
void foo(std::string* bar); // by address

附带说明，对于大于指针大小的类型，通过复制传递总是比通过引用或指针传递更昂贵。出于这个原因，您可能还更喜欢通过 const 引用传递，这将允许您读取对象而无需复制它。

void foo(const std::string& bar); // by const reference

但是，这一切都很棘手，您需要了解 Java 的微妙之处才能正确决定您想要 C++ 中的内容。在 Java 中，您实际上并没有通过引用传递对象：您是通过副本传递对象引用。也就是说，如果将新对象分配给参数，则父作用域的对象不会改变。在 C++ 中，这更接近于通过地址而不是通过引用来匹配传递对象。这是一个重要的例子：

// Java using "object references":
public static void foo(String bar)
{
    bar = "hello world";
}

public static void main(String[] argv)
{
    String bar = "goodbye world";
    foo(bar);
    System.out.println(bar); // prints "goodbye world"
}

// C++ using "references":
void foo(std::string& bar)
{
    bar = "hello world";
}

int main()
{
    std::string bar = "goodbye world";
    foo(bar);
    std::cout << bar << std::endl; // prints "hello world"
}

// C++ using pointers:
void foo(std::string* bar)
{
    bar = new std::string("goodbye world");
    delete bar; // you don't want to leak
}

int main()
{
    std::string bar = "goodbye world";
    foo(&bar);
    std::cout << bar << std::endl; // prints "hello world"
}

换句话说，当您在 C++ 中使用引用时，您实际上是在处理您传递的 同一个变量。您对其所做的任何更改，甚至是分配，都会反映到父范围。 （这部分是由于 C++ 处理赋值运算符的方式。）使用指针，您获得的行为与 Java 引用的行为更密切相关，代价是可能必须通过一元 & 获取对象地址运算符（参见我的示例中的foo(&bar)），需要使用-> 运算符来访问成员，以及使用运算符重载的一些额外复杂性。

另一个显着的区别是，由于引用参数的使用在语法上与复制参数的使用密切相关，因此函数应该能够假设您通过引用传递的对象是有效的。尽管通常可以传递对NULL 的引用，但非常不鼓励这样做，因为这样做的唯一方法是取消引用NULL，它具有未定义的行为。因此，如果您需要能够将NULL 作为参数传递，您会更喜欢通过地址而不是引用来传递参数。

大多数时候，当您想修改函数的参数时，您会希望通过引用而不是地址传递，因为它更“C++ 友好”（除非您需要 NULL 值），甚至虽然它并不完全像 Java 所做的那样。

Answer 2

C++ 默认按值传递。您可以通过编写函数来接受引用来隐式传递引用，或者通过传递指针来显式传递。

考虑以下三个例子：

FooByValue(Foo arg)
{
  //arg is passed by value.
}

FooByReference(Foo & arg)
{
  //arg is passed by reference.
  //changes made to arg will be seen by the caller.
}

FooByPointer(Foo * arg)
{
  //arg is passed by reference with pointer semantics.
  //changes made to the derefenced pointer (*arg) will be seen by the caller.
}

然后您可以按如下方式调用上述内容 Foo anObject;

FooByValue(anObject); //anObject will not be modified.
FooByRefence(anOBject); //anOBject may be modified.
FooByPointer(&anObject); //anObject may be modified.

& 符号当应用于像&anOBject 这样的变量时用于获取变量的地址，基本上给出了一个指向该变量存储在内存中的位置的指针。

FooByValue() 的操作与您的示例类似，FooByReference() 将保留函数调用后对参数所做的任何更改，因为不会复制参数，而是共享其在内存中的实际位置。

Answer 3

class Test {
 void dateReplaceReference(Date& arg) {
   // arg is passed by reference, modifying arg 
   // will modify it for the caller
 }
 void dateReplaceCopiedArgument(Date arg) {
   // arg is passed by value, modifying arg 
   // will not modify data for the caller
 }
 void dateReplaceByPointer(Date* arg) {
   // arg is passed as pointer, modifying *arg 
   // will modify it for the caller
 }
};

请注意，作为引用传递或通过指针传递是一回事。唯一的区别是您希望如何通过“。”访问数据。或通过“->”。此外，您不能将空值传递给采用引用的方法。