(*++argv)[0] 和 while(c = *++argv[0]) 之间的区别

Question

我有以下sn-p的代码：

int main(int argc, char *argv[])
{   

     char line[MAXLINE];
     long lineno = 0;
     int c, except = 0, number = 0, found = 0;

     while(--argc > 0 && (*++argv)[0] == '-') //These two lines
        while(c = *++argv[0])                 //These two lines
          switch(c) {
             case 'x':
                  except = 1;
                  break;
             case 'n':
                  number = 1;
                  break;
             default:
                  printf("find: illegal option %c\n", c);
                  argc = 0;
                  found = -1;
                  break;
          }

     ...
}

---

包含以下表达式：

while(--argc > 0 && (*++argv)[0] == '-')

括号中的 (*++argv)[0] 与不带括号的 while(c = *++argv[0]) 是否不同？

如果是这样，怎么做？ (*++argv) 是否表示指向下一个参数的指针，*++argv[0] 是否表示指向当前 char 数组中被指向的下一个字符的指针？

Answer 1

首先，K&R 对此特定 sn-p 有一个勘误表：

117(§5.10)：在 find 示例中，程序递增 argv[0]。这没有特别禁止，但也没有特别允许。

现在解释一下。

假设您的程序名为prog，并且您使用：prog -ab -c Hello World 执行它。您希望能够解析参数以说明选项 a、b 和 c 已指定，而 Hello 和 World 是非选项参数。

argv 的类型为char **——请记住，函数中的数组参数与指针相同。在程序调用时，情况如下所示：

                 +---+         +---+---+---+---+---+
 argv ---------->| 0 |-------->| p | r | o | g | 0 |
                 +---+         +---+---+---+---+---+
                 | 1 |-------->| - | a | b | 0 |
                 +---+         +---+---+---+---+
                 | 2 |-------->| - | c | 0 |
                 +---+         +---+---+---+---+---+---+
                 | 3 |-------->| H | e | l | l | o | 0 |
                 +---+         +---+---+---+---+---+---+
                 | 4 |-------->| W | o | r | l | d | 0 |
                 +---+         +---+---+---+---+---+---+
                 | 5 |-------->NULL
                 +---+

这里，argc 是 5，argv[argc] 是 NULL。开头，argv[0] 是一个 char *，包含字符串 "prog"。

在(*++argv)[0] 中，因为有括号，argv 先递增，然后再取消引用。增量的效果是将argv ----------> 箭头“向下移动一个块”，指向1。取消引用的效果是获得指向第一个命令行参数-ab 的指针。最后，我们取这个字符串的第一个字符（(*++argv)[0] 中的[0]），并测试它是否是'-'，因为那表示一个选项的开始。

对于第二个构造，我们实际上想要遍历当前argv[0] 指针所指向的字符串。因此，我们需要将argv[0] 视为一个指针，忽略它的第一个字符（即我们刚刚测试的'-'），并查看其他字符：

++(argv[0]) 将递增argv[0]，以获取指向第一个非- 字符的指针，并且取消引用它将为我们提供该字符的值。所以我们得到*++(argv[0])。但是因为在 C 中，[] 比++ 绑定得更紧密，我们实际上可以去掉括号，得到我们的表达式为*++argv[0]。我们要继续处理这个字符，直到它变成0（上图中每一行中的最后一个字符框）。

表达式

c = *++argv[0]

将当前选项的值分配给c，并且具有值c。 while(c) 是while(c != 0) 的简写，因此while(c = *++argv[0]) 行基本上是将当前选项的值分配给c 并对其进行测试以查看我们是否已到达当前命令行参数的末尾。

在这个循环结束时，argv 将指向第一个非选项参数：

                 +---+         +---+---+---+---+---+
                 | 0 |-------->| p | r | o | g | 0 |
                 +---+         +---+---+---+---+---+
                 | 1 |-------->| - | a | b | 0 |
                 +---+         +---+---+---+---+
                 | 2 |-------->| - | c | 0 |
                 +---+         +---+---+---+---+---+---+
 argv ---------->| 3 |-------->| H | e | l | l | o | 0 |
                 +---+         +---+---+---+---+---+---+
                 | 4 |-------->| W | o | r | l | d | 0 |
                 +---+         +---+---+---+---+---+---+
                 | 5 |-------->NULL
                 +---+

这有帮助吗？

Answer 2

增加 argv 是一个非常糟糕的主意，因为一旦你这样做了，就很难恢复原来的值。使用整数索引更简单、更清晰、更好——毕竟 argv 是一个数组！

要回答您的问题 ++argv 会增加指针。然后对其应用间接以获取第一个字符。

Answer 3

是的，你是对的。

while(--argc > 0 && (*++argv)[0] == '-')

正在逐一扫描命令行参数的数组（长度为 argc），寻找那些以 - 选项前缀开头的参数。对于每一个：

while(c = *++argv[0])

正在扫描当前参数中第一个- 后面的开关字符集（即-tn 中的t 和n，直到遇到字符串空终止符\0，这将终止while 循环，因为它的计算结果为 false。

这种设计允许两者

myApp -t -n

和

myApp -tn

工作并被理解为拥有t 和n 选项。

Answer 4

括号改变了表达式的计算顺序。

不带括号*++argv[0]:

1. argv[0] 获取指向当前由argv 指向的字符数据的指针。
2. ++ 将该指针递增到字符数组中的下一个字符。
3. * 获取角色。

带括号(*++argv)[0]:

1. ++argv 递增 argv 指针以指向下一个参数。
2. * 引用它以获得指向字符数据的指针。
3. [0] 获取字符数组中的第一个字符。

Answer 5

是的，这两种表达方式不同（尽管只是略有不同）。 IMO，这段代码有点过于聪明了。你最好用这样的东西：

for (int i=1; i<argc; i++)
    if (argv[i][0] == '-') {
       size_t len = strlen(argv[i]);
       for (int j=0; j<len; ++j)
           switch(argv[i][j]) {
               case 'x':
               // ...

这几乎等同于上面的代码，但我怀疑任何人（完全了解 C）都很难弄清楚它的真正作用。