函数调用的参数中可以使用后自增运算符吗？在 C?

Question

我的问题一般与函数调用有关，但我想到了 当我使用堆编写优先级队列时。只是为了提供一些上下文（不是很重要），我的堆从上到下从左到右存储项目，我将堆表示为结构数组。插入新项目后，我只是将其放在堆中的最后一个位置，然后调用底部的函数“fix_up”，它将将该项目移动到堆中的正确位置。我想知道如果不是做...

fix_up(pQueue->heap, pQueue->size);
pQueue->size++;

...我可以做...

fix_up(pQueue->heap, pQueue->size++);

出于几个原因，我不确定这是否可行。
1) 由于 pQueue->size 在函数调用中，我什至不确定它实际上是 pQueue->size 还是存储在 pQueue->size 中的整数的副本。如果它是一个副本，那么显然我不会将 1 添加到实际的 pQueue->size 中，所以这样做没有意义。

2) 因为它是一个函数调用，所以它会进入函数 fix_up 并执行那里的所有代码。我想知道这是否会产生意想不到的后果，即当它进入 fix_up 时，它会增加 1，并且我的索引会比我在执行 fix_up 时的预期高 1？或者它会做它应该做的事情并等到 fix_up 完成执行之后？

3) 即使没问题，它是否被认为是 C 语言的良好编码习惯？

Status priority_queue_insert(PRIORITY_QUEUE hQueue, int priority_level, int data_item)
{
    Priority_queue *pQueue = (Priority_queue*)hQueue;
    Item *temp_heap;
    int i;

    /*Resize if necessary*/
    if (pQueue->size >= pQueue->capacity) {
        temp_heap = (Item*)malloc(sizeof(Item) * pQueue->capacity * 2);
        if (temp_heap == NULL)
            return FAILURE;
        for (i = 0; i < pQueue->size; i++)
            temp_heap[i] = pQueue->heap[i];
        pQueue->capacity *= 2;
    }

    /*Either resizing was not necessary or it successfully resized*/
    pQueue->heap[pQueue->size].key = priority_level;
    pQueue->heap[pQueue->size].data = data_item;

    /*Now it is placed as the last item in the heap. Fixup as necessary*/
    fix_up(pQueue->heap, pQueue->size);
    pQueue->size++;

    //continue writing function code here
}

Answer 1

是的，你可以。

但是，您不能这样做：

foo(myStruct->size++, myStruct->size)

原因是 C 标准没有说明参数的计算顺序。这会导致未定义的行为。

1) 由于 pQueue->size 在函数调用中，我什至不确定它实际上是 pQueue->size 还是存储在 pQueue->size 中的整数的副本。如果它是一个副本，那么显然我不会将 1 添加到实际的 pQueue->size 中，所以这样做没有意义。

无论您向函数发送什么参数，都会在函数开始执行之前对其进行评估。所以

T var = expr;
foo(var);

总是等价于

foo(expr);

2) 因为它是一个函数调用，所以它会进入函数 fix_up 并执行那里的所有代码。我想知道这是否会产生意想不到的后果，即当它进入 fix_up 时，它会增加 1，并且我的索引会比我在执行 fix_up 时的预期高 1？或者它会做它应该做的事情并等到 fix_up 完成执行之后？

见上

3) 即使没问题，它是否被认为是 C 语言的良好编码习惯？

这个网站有点主观，有点过时，但我还是会从我个人的角度来回答。一般来说，我会尽量避免它。

Answer 2

虽然，其他帖子已经回答了这个问题，但他们都没有谈论Sequence Point的角色，在这种特殊情况下，这可以极大地帮助澄清OP的疑问。

来自this[强调我的]：

在对所有函数参数和函数指示符求值之后，在实际函数调用之前有一个序列点。

来自this[强调我的]：

增量运算符会引发将适当类型的值 1 添加到操作数的副作用。减量运算符启动从操作数中减去适当类型的值 1 的副作用。与任何其他副作用一样，这些操作在下一个序列点或之前完成。

此外，后自增运算符将操作数的值增加 1但表达式的值是自增操作之前操作数的原始值。

所以，在这个声明中：

fix_up(pQueue->heap, pQueue->size++);

pQueue->size 的值将在fix_up() 函数调用之前增加1，但参数值将是递增操作之前的原始值。

Answer 3

是的，您可以直接在作为参数传递的表达式中使用它。

类似的声明

fix_up(pQueue->heap, pQueue->size++);

有点等价于

{
    int old_value = pQueue->size;
    pQueue->size = pQueue->size + 1;
    fix_up(pQueue->heap, old_value);
}

---

关于上述“等效”示例的说明。由于未指定函数调用的参数评估顺序，pQueue->size 的实际增量可能发生在调用fix_up 之后。这也意味着在同一个调用中多次使用pQueue->size 会导致未定义的行为。

Answer 4

是的，您可以在函数调用中使用它，但请注意您的两个示例不等效。 pQueue->heap 参数可以在pQueue->size++ 之前或之后进行评估，您无法知道或依赖于顺序。考虑这个例子：

int func (void)
{
  static int x = 0;
  x++;
  return x;
}

printf("%d %d", func(), func());

这将打印1 2 或2 1，我们不知道我们会得到哪个。编译器不需要在整个程序中一致地评估函数参数。因此，如果我们添加第二个 printf("%d %d", func(), func());，我们可以得到类似 1 2 4 3 的输出。

这里的重要性是不要编写依赖于评估顺序的代码。这与在同一表达式中将 ++ 与其他操作或副作用混合是不好的做法的原因相同。在某些情况下，它甚至会导致未定义的行为。

回答您的问题：

1) 由于 pQueue->size 在函数调用中，我什至不确定它实际上是 pQueue->size 还是存储在 pQueue->size 中的整数的副本。如果它是一个副本，那么显然我不会将 1 添加到实际的 pQueue->size 中，所以这样做没有任何意义。

++ 应用于调用者中的变量，所以这不是问题。变量的本地副本发生在函数调用期间，与 ++ 无关。但是，++运算的结果并不是所谓的“左值”（可寻址数据），所以这段代码是无效的：

void func (int* a);
...
func(&x++);  

++ 优先并首先被评估。结果不是左值，无法获取其地址。

---

2) 因为它是一个函数调用，所以它会进入函数 fix_up 并执行那里的所有代码。我想知道这是否会产生意想不到的后果，即当它进入 fix_up 时，它会增加 1，并且我的索引会比我在执行 fix_up 时的预期高 1？或者它会做它应该做的事情并等到 fix_up 完成执行之后？

除非函数通过全局指针等修改原始变量，否则这不是问题。在这种情况下，您将遇到问题。例如

int* ptr;

void func (int a)
{
  *ptr = 1;
}

int x=5;
ptr = &x;
func(x++);

这是一个非常有问题的代码，x 将在 func(x++); 行之后为 1，而不是预期的 6。这是因为函数调用表达式在函数调用之前被求值并结束。

---

3) 即使没问题，它是否被认为是 C 语言的良好编码习惯？

在您的情况下它可以正常工作，但这是不好的做法。具体来说，将++ 或-- 运算符与同一个表达式中的其他运算符混合在一起是不好的（尽管很常见）做法，因为它很有可能出现错误并且往往会使代码的可读性降低。

您在自己的一行上带有pQueue->size++; 的原始代码在各方面都非常出色 - 坚持下去。与流行的看法相反，在编写 C 时，您不会因为“单行中的大多数运算符”而获得奖励积分。但是，您可能会遇到错误和维护问题。