C 传递值和指针

你能解释一下为什么输出是

3

？ 我试图找出答案，结果显示这条线

i+=(a==b?1:0)

给出

1

，但不

fun1（）

按值传递，所以

q

和

p

被复制到不同的变量

int fun1(int* a, int* b)
{
  int i = 0;
  i += (&a == &b ? 1 : 0);
  i += (a == b ? 1 : 0);
  i += (*a == *b ? 1 : 0);
  return i;
}
int fun2(int** a, int* b)
{
  int i = 0;
  i += (a == &b ? 1 : 0);
  i += (*a == b ? 1 : 0);
  return i;  
}
int main(void)
{
  int i = 0;
  int* p = &i;
  int* q = &i;

  printf("%d\n", fun1(p, q) + fun2(&p, q));
  return 0;  
}

---

a==b

实际上是在测试

a

和

b

是否指向相同的内存位置。在函数

fun1

中，

a

和

b

都指向相同的内存位置，因此

a==b

结果为

true

a==b

实际上是在测试

a

和

b

是否指向相同的内存位置。在函数

fun1

中，

a

和

b

都指向相同的内存位置，因此

a==b

结果为

true

int fun1(int *a, int*b)
{
    int i=0;
    i+=(&a==&b?1:0); // 0. &a is the memory where a stands. it's different from &b.
    i+=(a==b?1:0); // 1. Both pointers point to the same memory.
    i+=(*a==*b?1:0); // 1. *a is the value where it points to, and that's the same as *b.
    return i; // returns 2

}
int fun2(int **a, int*b)
{
    int i=0;
    i+=(a==&b?1:0); // 0
    i+=(*a==b?1:0); // 1. *a is the value where it points to, and this is a memory value that is the same as b.
    return i; // returns 1

}

这就是它返回3的原因

顺便提一下，问得好

这就是它返回3的原因

顺便提一下，问得好。

在

fun1

中：

（&a==&b？1:0）

这将给出

0

。它们是fun1的两个不同参数，基本上是两个不同的局部变量，因此它们不能有相同的地址

（a==b？1:0）

这将产生

1

。这些值都是来自

main

的

&i

（*a==*b？1:0）

这将产生

1

。因为

a

和

b

是相等的，所以它们指向同一事物

在

fun2

中：

（a==&b？1:0）

这将给出

0

a

和

b

都是参数，因此

a

不能等于

b

的地址（实际上，它等于main中的

&p

）

（*a==b？1:0）

这将产生

1

a

等于main中的

&p

，因此

*a

等于main中的

p

，main中的

&i

。而

b

等于main中的

q

，这也是main中的

&i

因此，在

fun1

中，总数为

3
：

（&a==&b？1:0）

这将给出
0
。它们是fun1

的两个不同参数，基本上是两个不同的局部变量，因此它们不能有相同的地址

（a==b？1:0）

这将产生

1

。这些值都是来自

main

的

&i

（*a==*b？1:0）

这将产生

1

。因为

a

和

b

是相等的，所以它们指向同一事物

在

fun2

中：

（a==&b？1:0）

这将给出

0

a

和

b

都是参数，因此

a

不能等于

b

的地址（实际上，它等于main中的

&p

）

（*a==b？1:0）

这将产生

1

a

等于main中的

&p

，因此

*a

等于main中的

p

，main中的

&i

。而

b

等于main中的

q

，这也是main中的

&i

---

<>总的是<代码> 3 >代码>

让我们首先考虑第一个函数

int fun1(int *a, int*b)
{
    int i=0;
    i+=(&a==&b?1:0);
    i+=(a==b?1:0);
    i+=(*a==*b?1:0);
    return i;
}

它被称为

fun1(p,q)

两个指针都指向同一个变量

int *p=&i;
int *q=&i;

所以这个函数得到了两个相等的值作为它的参数。它是变量

i

的地址

函数参数是它的局部变量。您可以想象被调用的函数如下

int fun1( /*int *a, int*b */)
{
    int *a = p;
    int *b = q;
    //...
}

这些局部变量占用不同的内存范围。所以

&a

不等于

&b

因此，表达式

（&a==&b？1:0）

的值将等于0，并且在下面的语句中变量

i

i+=(&a==&b?1:0);

    i+=(a==b?1:0);

不会改变

变量

a

和

b

中存储的值标识了

main

中变量

i

的地址。正如前面所说，这两个变量包含相同的值。 所以表达式

（a==b？1:0）

将在下面的语句中产生1和变量

i

i+=(&a==&b?1:0);

    i+=(a==b?1:0);

将增加

当两个指针指向同一个对象时，表达式

（*a==*b？1:0）

也将产生1。结果变量

i

将增加/

    i+=(*a==*b?1:0);

该函数将返回值2

现在让我们考虑第二个函数

int fun2(int **a, int*b)
{
    int i=0;
    i+=(a==&b?1:0);
    i+=(*a==b?1:0);
    return i;
}

如上所述，参数

b

是函数的局部变量。它的地址不等于参数的地址

p

所以表达式

（a==&b？1:0）

得到0

表达式

*a

是存储在参数

p

中的值相同的值存储在参数

b

所以表达式

（*a==b？1:0）

得到1

---

函数的返回值之和将等于3。

让我们首先考虑第一个函数

int fun1(int *a, int*b)
{
    int i=0;
    i+=(&a==&b?1:0);
    i+=(a==b?1:0);
    i+=(*a==*b?1:0);
    return i;
}

它被称为

fun1(p,q)

两个指针都指向同一个变量

int *p=&i;
int *q=&i;

所以这个函数得到了两个相等的值作为它的参数。它是变量

i

的地址

函数参数是它的局部变量。您可以想象被调用的函数如下

int fun1( /*int *a, int*b */)
{
    int *a = p;
    int *b = q;
    //...
}

这些局部变量占用不同的内存范围。所以

&a

不等于

&b

因此，表达式

（&a==&b？1:0）

的值将等于0，并且在下面的语句中变量

i

i+=(&a==&b?1:0);

    i+=(a==b?1:0);

不会改变

变量

a

和

b

中存储的值标识了

main

中变量

i

的地址。正如前面所说，这两个变量包含相同的值。 所以表达式

（a==b？1:0）

将在下面的语句中产生1和变量

i

i+=(&a==&b?1:0);

    i+=(a==b?1:0);

将增加