Question

我知道通过指针调用，其中我们传递变量的地址。这样的事情：

void swap(int *x, int *y)
{
   int temp;
   temp = *x; /* save the value at address x */
   *x = *y; /* put y into x */
   *y = temp; /* put x into y */

   return;
}

  swap(&a, &b);

并且按引用调用，在这两种方法中，函数中所做的更改都反映在实际参数的变量中。
但是为什么在这种情况下传递的实际参数没有改变：

#include <iostream>
using namespace std;
void foo(int* c){
c=c+1;
}
int main()
{
    int a=5;
    int *c=&a;
    cout<<&c<<endl; //0x7ffe1a74f3b0
    foo(c);        
    cout<<*c<<endl;//5
    cout<<&c<<endl;//0x7ffe1a74f3b0
}

这里传递给foo（）的地址是a的地址。这是如何按值调用的根据我的说法， c 应该有打印的垃圾值。请解释这里发生的事情。

Answer 1

并且还通过引用调用，在这两种方法中，函数中所做的更改都反映在实际参数中。变量

但是有一个重要的区别：更改总是针对引用/指向的内容，而不是引用/指针本身（通常不可能修改引用）。

这就是为什么在Something went wrong, insufficient components in ro1|no1|ap1|ge1 nombre = no2 apellidos = ap2 genero = ge2 fecha_nacimiento = fn2 ruta_obtenida = ro2 valid_pieces_count = 1内为c分配一个新值对foo以外的c没有影响：传递给函数的指针是复制的

如果需要修改指针，则需要通过将指针引用或指针传递给指针来添加另一级别的引用。

Answer 2

继续发表评论后，函数c中定义的变量main是与函数c的参数foo不同的变量。如果您希望foo能够修改主c，那就是修改c指针类型所包含的地址，那么您需要通过相反，c指向函数的引用或指针。

以下是一个示例，显示了按值（c）或引用（int *或int **）传递int *&之间的区别。不要被int *指针类型这一事实所迷惑，这意味着它可以通过引用接收int或按值int *接收c。由于主int * int而不是c，因此主c正在按值传递。

注意调用函数的方式不同（函数调用中&是否需要地址运算符#include <iostream> using namespace std; void foo_int_ptr(int* c) { c=c+1; } void foo_int_ptr_ptr(int** c) { *c=*c+1; } void foo_int_ptr_ref(int*& c) { c=c+1; } int main() { int a=5; int *c=&a; cout << "&c=" << &c << ", c=" << c << ", *c=" << (c==&a ? std::to_string(*c) : std::string("INVALID PTR")) << endl; foo_int_ptr(c); cout << "&c=" << &c << ", c=" << c << ", *c=" << (c==&a ? std::to_string(*c) : std::string("INVALID PTR")) << endl; foo_int_ptr_ptr(&c); cout << "&c=" << &c << ", c=" << c << ", *c=" << (c==&a ? std::to_string(*c) : std::string("INVALID PTR")) << endl; foo_int_ptr_ref(c); cout << "&c=" << &c << ", c=" << c << ", *c=" << (c==&a ? std::to_string(*c) : std::string("INVALID PTR")) << endl; }）和每个函数的结果。

&c=0x7e02d81808b8, c=0x7e02d81808ac, *c=5
&c=0x7e02d81808b8, c=0x7e02d81808ac, *c=5
&c=0x7e02d81808b8, c=0x7e02d81808b0, *c=INVALID PTR
&c=0x7e02d81808b8, c=0x7e02d81808b4, *c=INVALID PTR

输出：

<?xml version="1.0"?>

<!--
  ~ Hibernate, Relational Persistence for Idiomatic Java
  ~
  ~ License: GNU Lesser General Public License (LGPL), version 2.1 or later.
  ~ See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
  -->
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="org.hibernate.tutorial.hbm">
    <class name="Event" table="EVENTS">
        <id name="id" column="EVENT_ID">
            <generator class="increment"/>
        </id>
        <property name="date" type="timestamp" column="EVENT_DATE"/>
        <property name="title"/>
    </class>
</hibernate-mapping>

Answer 3

你对此的想法有误......

int *c = &a;

这并不意味着c“包含”a的地址，这意味着c是指向a的地址的指针。将指针传递给foo（）将不会执行任何操作。

为什么在main（）中声明的指针没有改变？

3 个答案: