通过在 C 中的引用传递来修改函数内部的字符串

Question

所以，我遇到了一个我不太了解的问题。请善待我正在尝试自学C！

我有一个名为 secureInput() 的函数，它接受一个指向字符串的指针和一个 size，这样，当用户必须输入一些输入我可以确定没有缓冲区溢出。现在，问题是我想修改字符串而不复制它，而是直接通过它的内存地址修改它，但是当用户输入中的第二个字符被分配时它就会崩溃。查看 cmets 以了解它在哪里崩溃。

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

int secureInput(char **str, int size);

int main(int argc, const char * argv[]) {
    char *mystring = NULL; // Declaring it a null so that I use malloc later
    secureInput(&mystring, 10);
    printf("%s\n", mystring);

}


int secureInput(char **str, int size)
{
    *str = (char*)malloc(sizeof(char) *size);  // Because **str is a null pointer, I use malloc to allocate memory.
    if (*str == NULL)
        return -1;

    int c = 0;
    unsigned int count = 0;
    while((c = getchar()) != '\n' && count < size)
        /* Here is where it crashes.
         * But changing the bellow line as : *str[0][count++] = c;
         * works as expected. Also, using a temporary pointer
         * and later using it to replace *str, is also working
         */
    
        *str[count++] = c;
    *str[count] = '\0';

    return 0;
}

Answer 1

至少这个问题：

减一

str[count] = '\0'; 可以在数组边界外写入导致 OP 的麻烦。建议count < size --> count + 1 < size.

并非总是读取整行

读取部分行会导致麻烦。

阅读整行并报告结果如何？让调用代码提供固定大小的缓冲区。

区分读取空行和文件结尾。

优雅地处理size == 0。

// EOF: end-of-file with no input
// EOF: input error
// 0: input, but too much
// 1: Success
int secureInput(char *str, size_t size) {
  if (str == NULL) {
    size = 0;
  }

  bool too_many = false;
  size_t count = 0;
  int c;
  while((c = getchar()) != '\n') {
    if (c == EOF) {
      if (feof(stdin) && count > 0) {
        break;
      }
      if (size > 0) {
        str[0] = '\0';
      }
      return EOF;
    }

    if (count + 1 < size) {
      str[count++] = c;
    } else {
      too_many = true;
    }
  }

  if (count < size) {
    str[count] = '\0';
  } 
  return count < size && !too_many;
}

Answer 2

首先，您可以将字符串作为char* 传递，而不需要char**。当作为参数传递时，这通常用于字符串数组。然后，如果你想使用一个固定大小的数组，一个缓冲区，它有一个恒定的、预定义的大小，不要使用 malloc。动态内存分配总是低效且有风险的，所以只有在绝对必要时才使用它。

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

#define BUFFER_SIZE 10

int secureInput(char *str, int size);

int main(int argc, const char * argv[]) {
    char mystring[BUFFER_SIZE]; // Declaring it a null so that I use malloc later
    memset(mystring, 0, BUFFER_SIZE);
    secureInput(mystring, BUFFER_SIZE);
    printf("%s\n", mystring);
}

int secureInput(char *str, int size) {

    char c = 0;
    unsigned int count = 0;
    
    c = getchar();
    while(c != '\n' && count < size - 1) {
        str[count++] = c;
        c = getchar();
    }
    str[count] = '\0';

    return 0;
}

编辑：

我可以看到指针算法仍然存在一些混淆。下面是一些地址打印和一个小图，希望对你有帮助：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

int secureInput(char **str, int size);

int main(int argc, const char * argv[]) {
    char *mystring = NULL; // Declaring it a null so that I use malloc later
    secureInput(&mystring, 10);
}


int secureInput(char **str, int size) {
    *str = (char*)malloc(sizeof(char) *size);  // Because **str is a null pointer, I use malloc to allocate memory.
    (*str)[0] = 'a';
    (*str)[1] = 'b';
    (*str)[2] = 'c';
    (*str)[3] = 0;
    printf("address of the pointer that points to a pointer that points the first char of the array : %p\n", &str);
    printf("value of the pointer that points to a pointer that points to the first char of the array : %p\n", str);
    printf("address of the pointer that points to the first char of the array : %p\n", &(*str));
    printf("value of the pointer that points to the first char of the array : %p\n", *str);
    printf("address of the first char of the array: %p\n", &(**str));
    printf("address of the seconds char of the array: %p\n", &((*str)[1]));
    printf("value of the first char of the array : %c\n", **str);
    printf("value of the second char of the array : %c\n", *(*str + 1));
    printf("value of the second char of the array : %c\n", (*str)[1]);
    printf("*str[1] is the same as *(str[1]), which runs to a segmentation fault\n");
    return 0;
}

输出：

address of the pointer that points to a pointer that points the first char of the array : 0x7ffce24333f8
value of the pointer that points to a pointer that points to the first char of the array : 0x7ffce2433430
address of the pointer that points to the first char of the array : 0x7ffce2433430
value of the pointer that points to the first char of the array : 0x55a91985a2a0
address of the first char of the array: 0x55a91985a2a0
address of the seconds char of the array: 0x55a91985a2a1
value of the first char of the array : a
value of the second char of the array : b
value of the second char of the array : b
*str[1] is the same as *(str[1]), which runs to a segmentation fault

     0x7ffce24333f8              0x7ffce2433430              
   +----------------+          +----------------+          +----------------+
   | 0x7ffce2433430 | -------> | 0x55a91985a2a0 | -------> |       a        | 0x55a91985a2a0
   +----------------+          +----------------+          +----------------+
   
                                                           +----------------+
                                                           |       b        | 0x55a91985a2a1
                                                           +----------------+
   
                                                           +----------------+
                                                           |       c        | 0x55a91985a2a2
                                                           +----------------+

关键是你取消引用哪个指针很重要。