为什么这两个char*变量的值没有'；退出该功能后是否会发生变化？

我正在填充一个C程序，将两个输入向量相乘。代码如下：

/**
 * Function name: parseArguments
 * Description:
 *    Determine what options or arguments user used
 *    Command-line options:
 *   [-h]    : Show help information
 *   [-n] num: Determine number of threads
 *   file1   : Choose first file
 *   file2   : Choose second file
 * Return value:
 *    0: If parsing successful
 *    exit: If error
 **/
static int parseArguments(int argc, char **argv, int* nthreads, char* file1, char* file2)
{
  int opt;
  int help=0;
  extern int optind;
  extern char * optarg;    // (global variable) command-line options

  while ((opt = getopt(argc, argv, "hn:")) != EOF)
  {
    switch (opt) {
      //Parse option -h, -n
      case 'n':
        *nthreads = atoi(optarg);
        break;
    case 'h':
        Usage();
        exit(1);
        break;
      default:
        fprintf(stderr, "Try 'mulvector -h' for more information\n");
        exit(1);
    }


    // parse file1 & file2 arguments
// THIS IS WHAT I'M ASKING
        if (optind < argc)
    {
        file1 = &argv[optind];
        optind++;
    }
    if (optind < argc)
        file2 = &argv[optind];
  }

  return 0;
}

/**
*函数名：parseArguments
*说明：
*确定用户使用的选项或参数
*命令行选项：
*[-h]：显示帮助信息
*[-n]num：确定线程数
*文件1：选择第一个文件
*文件2：选择第二个文件
*返回值：
*0:如果解析成功
*退出：如果出现错误
**/
静态int-parseArguments（int-argc，char**argv，int*nthreads，char*file1，char*file2）
{
int-opt；
int help=0；
外部-内部选项；
extern char*optarg；//（全局变量）命令行选项
而（（opt=getopt（argc，argv，hn:）！=EOF）
{
开关（opt）{
//解析选项-h，-n
案例“n”：
*nthreads=atoi（optarg）；
打破
案例“h”：
用法（）；
出口（1）；
打破
违约：
fprintf（stderr，“有关详细信息，请尝试使用'mulvector-h'”）；
出口（1）；
}
//解析file1和file2参数
//这就是我要问的
如果（选项D

问题是，在我调用这个函数（在main（）函数中）然后退出这个函数（继续main（）函数）之后，两个变量file1和file2在执行parseArguments函数之前仍然保留它们的旧值。我正试图解决这个问题，但没有结果

希望你们能帮忙，非常感谢你们的帮助

---

注意：file1和file2的类型是char file1[1024]，因此我不能使用char**作为parseArguments函数的参数

C按值传递参数。因此，您对

file1

和

file2

所做的修改只是对函数中指针的本地副本的修改。调用方看不到这些更改

您可能希望：

将文本复制到

file1

和

file2

引用的缓冲区，或

将

file1

和

file2

的地址传递给函数，并修改调用者看到的值

选项1如下所示：

static int parseArguments(..., char* file1, char* file2)
{
    ....
    strcpy(file1, argv[optind]);
    ....
    strcpy(file2, argv[optind]);
    ....
}

static int parseArguments(..., char** file1, char** file2)
{
    ....
    *file1 = &argv[optind];
    ....
    *file2 = &argv[optind];
    ....
}

static int parseArguments(int argc, char **argv, int* nthreads, 
  char* file1, size_t size1, 
  char* file2, size_t size2)
{
  ...
  memset(file1, 0, size1);
  strncpy(file1, argv[optind], size1 - 1);

当然，这要求缓冲区溢出。因此，传递缓冲区的长度以允许代码避免溢出也是明智的，例如使用

strncpy

或

strncat

。这里对这个问题进行了很好的讨论：

选项2如下所示：

static int parseArguments(..., char* file1, char* file2)
{
    ....
    strcpy(file1, argv[optind]);
    ....
    strcpy(file2, argv[optind]);
    ....
}

static int parseArguments(..., char** file1, char** file2)
{
    ....
    *file1 = &argv[optind];
    ....
    *file2 = &argv[optind];
    ....
}

static int parseArguments(int argc, char **argv, int* nthreads, 
  char* file1, size_t size1, 
  char* file2, size_t size2)
{
  ...
  memset(file1, 0, size1);
  strncpy(file1, argv[optind], size1 - 1);

---

C按值传递参数。因此，您对

file1

和

file2

所做的修改只是对函数中指针的本地副本的修改。调用方看不到这些更改

您可能希望：

将文本复制到

file1

和

file2

引用的缓冲区，或

将

file1

和

file2

的地址传递给函数，并修改调用者看到的值

选项1如下所示：

static int parseArguments(..., char* file1, char* file2)
{
    ....
    strcpy(file1, argv[optind]);
    ....
    strcpy(file2, argv[optind]);
    ....
}

static int parseArguments(..., char** file1, char** file2)
{
    ....
    *file1 = &argv[optind];
    ....
    *file2 = &argv[optind];
    ....
}

static int parseArguments(int argc, char **argv, int* nthreads, 
  char* file1, size_t size1, 
  char* file2, size_t size2)
{
  ...
  memset(file1, 0, size1);
  strncpy(file1, argv[optind], size1 - 1);

当然，这要求缓冲区溢出。因此，传递缓冲区的长度以允许代码避免溢出也是明智的，例如使用

strncpy

或

strncat

。这里对这个问题进行了很好的讨论：

选项2如下所示：

static int parseArguments(..., char* file1, char* file2)
{
    ....
    strcpy(file1, argv[optind]);
    ....
    strcpy(file2, argv[optind]);
    ....
}

static int parseArguments(..., char** file1, char** file2)
{
    ....
    *file1 = &argv[optind];
    ....
    *file2 = &argv[optind];
    ....
}

static int parseArguments(int argc, char **argv, int* nthreads, 
  char* file1, size_t size1, 
  char* file2, size_t size2)
{
  ...
  memset(file1, 0, size1);
  strncpy(file1, argv[optind], size1 - 1);

---

C按值传递参数。因此，您对

file1

和

file2

所做的修改只是对函数中指针的本地副本的修改。调用方看不到这些更改

您可能希望：

将文本复制到

file1

和

file2

引用的缓冲区，或

将

file1

和

file2

的地址传递给函数，并修改调用者看到的值

选项1如下所示：

static int parseArguments(..., char* file1, char* file2)
{
    ....
    strcpy(file1, argv[optind]);
    ....
    strcpy(file2, argv[optind]);
    ....
}

static int parseArguments(..., char** file1, char** file2)
{
    ....
    *file1 = &argv[optind];
    ....
    *file2 = &argv[optind];
    ....
}

static int parseArguments(int argc, char **argv, int* nthreads, 
  char* file1, size_t size1, 
  char* file2, size_t size2)
{
  ...
  memset(file1, 0, size1);
  strncpy(file1, argv[optind], size1 - 1);

当然，这要求缓冲区溢出。因此，传递缓冲区的长度以允许代码避免溢出也是明智的，例如使用

strncpy

或

strncat

。这里对这个问题进行了很好的讨论：

选项2如下所示：

static int parseArguments(..., char* file1, char* file2)
{
    ....
    strcpy(file1, argv[optind]);
    ....
    strcpy(file2, argv[optind]);
    ....
}

static int parseArguments(..., char** file1, char** file2)
{
    ....
    *file1 = &argv[optind];
    ....
    *file2 = &argv[optind];
    ....
}

static int parseArguments(int argc, char **argv, int* nthreads, 
  char* file1, size_t size1, 
  char* file2, size_t size2)
{
  ...
  memset(file1, 0, size1);
  strncpy(file1, argv[optind], size1 - 1);

---

C按值传递参数。因此，您对

file1

和

file2

所做的修改只是对函数中指针的本地副本的修改。调用方看不到这些更改

您可能希望：

将文本复制到

file1

和

file2

引用的缓冲区，或

将

file1

和

file2

的地址传递给函数，并修改调用者看到的值

选项1如下所示：

static int parseArguments(..., char* file1, char* file2)
{
    ....
    strcpy(file1, argv[optind]);
    ....
    strcpy(file2, argv[optind]);
    ....
}

static int parseArguments(..., char** file1, char** file2)
{
    ....
    *file1 = &argv[optind];
    ....
    *file2 = &argv[optind];
    ....
}

static int parseArguments(int argc, char **argv, int* nthreads, 
  char* file1, size_t size1, 
  char* file2, size_t size2)
{
  ...
  memset(file1, 0, size1);
  strncpy(file1, argv[optind], size1 - 1);

当然，这要求缓冲区溢出。因此，传递缓冲区的长度以允许代码避免溢出也是明智的，例如使用

strncpy

或

strncat

。这里对这个问题进行了很好的讨论：

选项2如下所示：

static int parseArguments(..., char* file1, char* file2)
{
    ....
    strcpy(file1, argv[optind]);
    ....
    strcpy(file2, argv[optind]);
    ....
}

static int parseArguments(..., char** file1, char** file2)
{
    ....
    *file1 = &argv[optind];
    ....
    *file2 = &argv[optind];
    ....
}

static int parseArguments(int argc, char **argv, int* nthreads, 
  char* file1, size_t size1, 
  char* file2, size_t size2)
{
  ...
  memset(file1, 0, size1);
  strncpy(file1, argv[optind], size1 - 1);

如果要修改指针对象，必须向函数传递指向指针的指针，而不仅仅是指针对象值

即:

char **file1, char **file2

而不是

char* file1, char* file2

如果要修改指针对象，必须向函数传递指向指针的指针，而不仅仅是指针对象值

即:

char **file1, char **file2

而不是

char* file1, char* file2

如果要修改指针对象，必须向函数传递指向指针的指针，而不仅仅是指针对象值

即:

char **file1, char **file2

而不是

char* file1, char* file2

如果要修改指针对象，必须向函数传递指向指针的指针，而不仅仅是指针对象值

即:

char **file1, char **file2

而不是

char* file1, char* file2

---

C是按值传递的，即使对于指针也是如此。如果要更改指针，需要传递