Question

我对比较Java和C++引用感到困惑：

在java的下面代码中，Point p对象在调用(5,5)后仍然指向changePoint对象。

这是因为temp变量（在chagePoint中）在堆栈上分配并保存对堆中p对象（在main中）的引用但是当我们重新分配temp时，它只指向堆中的另一个point对象而不改变main中原始Point p对象所指向的位置。

public static void main(String [] args) {
    Point p = new Point(5,5);
    changePoint(p);
}

changePoint(Point temp) {
    temp = new Point(4,6);
}

现在在C ++中如果我们做同样的事情，在(5,5)中执行这两个语句之后，main中的changePoint对象会发生什么？当你执行*temp = new Point(4,5)时，它会简单地覆盖(5,5)从{main}指向的p对象？但是当你执行temp = new Point（4,5）时，main中的(5,5)对象会出现内存泄漏吗？

int main() {
    Point *p = new Point(5,5);
    changePoint(&p);
}

changePoint(Point *temp) {
    *temp = new Point(4,5);
    temp = new Point (5,6);
}

Answer 1

在与Java比较之前，您应该了解以下内容：

C ++通过引用传递vs传递值（复制）。
指针指针。

在C ++中，如果要修改传递给函数的变量，则需要通过引用传递：

void func1(int& value)
{
  value = 5;
}
void another_function()
{
  int number = 0;
  func(number);
  std::cout << "The value of number is: " << number << "\n";
}

number的值将由func更改，因为变量是通过引用传递的。

如果要使用指针而不是引用来修改变量，则需要传递指针：

void func2(int * pointer_to_value)
{
  *pointer_to_value = 16;
}
void caller()
{
  int number = 0;
  func2(&number);
  std::cout << "The value of number is: " << number << "\n";
}

如果要更改指针而不通过引用传递，则需要将指针传递给指针：

void func3(int * * pointer_to_point_to_value)
{
  *pointer_to_pointer_to_value = new int;
  **pointer_to_pointer_to_value = 23;
}
void caller3()
{
  int * pointer_to_number;
  func3(&pointer_to_number);
  cout << "Number is: " **pointer_to_number << "\n";
}

更简单的方法是通过引用传递指针：

void func4(int * & pointer_to_value)
{
  pointer_to_value = new int;
  *pointer_to_value = 17;
}
void caller4()
{
  int * pointer_to_number;
  func4(pointer_to_number);
}

就阵列而言，简化您的生活并使用std::vector。通过引用传递矢量变量，或者如果不通过常量引用修改它。

更改C ++指针指向的位置

1 个答案: