malloc和strcpy，入门的指针面试题

指针是C和C++编程语言中一个重要的概念，因此在面试以及工作中经常会涉及到指针相关的问题，现在列举几个比较基础问题。

一、

void getMemory( char *p )
{
 p = (char *) malloc( 100 );
}
void test( void ) 
{
 char *str = NULL;
 getMemory( str ); ///
 strcpy( str, "hello world" );
 printf( str );
}

这段代码有一个问题是在函数getMemory中，对于初学者来说，肯定想当然认为，类型一样，还有什么问题？指针p被重新赋值为一个新的内存空间的地址，但是这个修改不会影响到函数外部的实参str指向的内存空间，相当于传了NULL，因为是要改变这个值的指向，要传他的本身的指针，也就是指针的指针。因此，在调用strcpy函数时，传递的是一个未初始化的指针，会导致未定义的行为。

修复这个问题的方式有两种：

将函数GetMemory返回分配的内存指针，并将其赋值给str指针。

char * getMemory( void )
{
    char * p = ( char * )malloc( 100 );
    return p;
}

void test( void ) 
{
 char * str = NULL;
 str = getMemory(); 
 strcpy( str, "hello world" );
 printf( str );
}

int main()
{
  test();
  return 0;
}

将函数GetMemory参数改为指向指针的指针类型，并通过间接寻址方式来修改指针的值。

void getMemory( char ** p )
{
    *p = ( char * )malloc( 100 );
}

void test( void ) 
{
 char *str = NULL;
 getMemory( &str ); //遇到这种二级指针，在数据结构二叉树也是经常遇到的
 strcpy( str, "hello world" );
 printf( str );
}

int main()
{
  test();
  return 0;
}

二叉树的每个节点都有两个子节点，因此二叉树可以用指向节点的指针表示。在函数中需要修改指向节点的指针时，我们可以使用指向指针的指针（即二级指针）来进行操作。以下是构建二叉树的示例代码：

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

// 定义二叉树节点结构体
typedef struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

// 向二叉树中插入一个新节点
void insert(TreeNode **root, int val) {
    if (*root == NULL) {
        // 当前节点为空，创建一个新节点
        *root = (TreeNode *)malloc(sizeof(TreeNode));
        (*root)->val = val;
        (*root)->left = NULL;
        (*root)->right = NULL;
    } else if (val < (*root)->val) {
        // 新节点值小于当前节点值，递归插入左子树
        insert(&((*root)->left), val);
    } else {
        // 新节点值大于等于当前节点值，递归插入右子树
        insert(&((*root)->right), val);
    }
}

// 中序遍历二叉树
void inorder(TreeNode *root) {
    if (root == NULL) {
        return;
    }
    inorder(root->left);
    printf("%d ", root->val);
    inorder(root->right);
}

int main() {
    TreeNode *root = NULL; // 创建一棵空树
    insert(&root, 5);
    insert(&root, 3);
    insert(&root, 7);
    insert(&root, 1);
    insert(&root, 9);
    inorder(root); // 中序遍历输出：1 3 5 7 9
    return 0;
}

在这个示例代码中，我们定义了一个二叉树节点结构体，并使用指向指针的指针（即二级指针）来插入新节点和修改树的结构。

二、

void test( void )
{
 char *str = (char *) malloc( 100 );
 strcpy( str, "hello" );
 free( str ); 
 ... //省略的其它语句
}

这段代码中存在一个问题，即在调用完free函数之后，指针str仍然指向了被释放的内存空间。虽然这个指针已经被释放，但是它的值并没有被修改，因此在继续使用该指针时可能会导致未定义的行为，例如访问非法内存、数据损坏等。为避免这个问题，我们可以在调用free函数之后将指针str赋值为NULL，这样在继续使用该指针时就会导致段错误（segmentation fault）等异常，这个经常在工作中会遇到，从而更容易发现问题。

三、

void test()
{
int *p = (int *)malloc(INT_MAX/4);
*p = 20;//如果p的值是NULL，就会有问题   进行判断是否为空
free(p);
}

这段代码中存在一个问题，即在申请内存空间时使用了INT_MAX/4这么大的内存，这可能导致失败或者内存不足，从而导致malloc函数返回NULL。此时如果直接对指针进行解引用赋值操作，会导致程序运行异常。

为避免这个问题，我们需要在调用malloc函数之后判断其返回值是否为NULL，以确保分配内存成功。修复这个问题的方式：

void test()
{
  int *p = (int *)malloc(INT_MAX/4);
  if (p == NULL) {
    printf("Failed to allocate memory\n");
    return;
  }
  *p = 20;
  free(p);
}

四、

void test()
{
  int i = 0;
  int *p = (int *)malloc(10*sizeof(int)); //分配40个字节空间
  if(NULL == p)
  {
    exit(0); //分配失败就退出
  }
  for(i=0; i<=10; i++) 
  {
    *(p+i) = i;//当i是10的时候越界访问
  }
    free(p);
  }

这段代码存在一个问题，即在使用for循环赋值时，数组下标从0到10共11个，而p指向的内存空间只有10个int型变量（40字节），也就是说当i等于10时数组已经越界访问，这会导致未定义的行为。

修复这个问题的方式是将for循环中的判断条件修改为i<10，即数组下标最大只能是9，不会越界访问。例如：

void test()
{
  int i = 0;
  int *p = (int *)malloc(10*sizeof(int)); //分配40个字节空间
  if(NULL == p)
  {
    exit(0); //分配失败就退出
  }
  for(i=0; i<10; i++) 
  {
    *(p+i) = i;
  }
    free(p);
}

五、

void test()
{
int *p = (int *)malloc(100);
p++;
free(p);//p不再指向动态内存的起始位置
} 

这段代码存在一个问题，即在调用free函数时，指针p已经不再指向动态内存的起始位置，这会导致free函数释放的内存空间不正确，如果在释放内存之前修改了指向该内存的指针，则可能导致内存泄漏或者程序崩溃，不能正确进行释放空间，因为其实地址不见，free就找不到正确释放内存的大小。在调用malloc()或calloc()函数时，系统会自动记录该内存块的大小，以便在调用free()函数时准确地释放相应的内存。

六、

char *getMemory(void)
{
  char p[] = "hello world";
  return p;
}
void test(void)
{
  char *str = NULL;
  str = getMemory();
  printf(str);
}
int main()
{
  test();
  return 0;
}

这段代码有一个问题是返回了一个局部变量的地址，具体来说，函数getMemory中定义了一个字符数组p， 并将其初始化为字符串"hello world"，然后将p的地址作为返回值。但是由于p是一个局部变量， 在函数返回时它所占用的内存会被回收，因此在调用getMemory函数并将返回值赋给指针str后， str指向的内存空间已经无效，访问该空间就会导致未定义的行为。修复这个问题的方式是将p声明为静态数组或者使用动态内存分配函数（如malloc）分配堆上的内存空间。例如：

char *getMemory(void)
{
  static char p[] = "hello world";
  return p;
}
void test(void)
{
  char *str = NULL;
  str = getMemory();
  printf("%s", str);
}
int main()
{
  test();
  return 0;
}

七、

以下是一个错误使用 strcpy 函数的代码题：

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

int main(void) {
    char src[10] = "Hello!";
    char dest[5];

    // 错误示范：dest 的大小只有 5，无法容纳源字符串 "Hello!"
    strcpy(dest, src);

    printf("src: %s\n", src);
    printf("dest: %s\n", dest);

    return 0;
}

在这个例子中，我们声明了两个字符数组 src 和 dest，并将字符串 “Hello!” 存储在 src 中。然后使用 strcpy 函数将 src 中的字符串复制到 dest 中。由于 dest 的大小只有 5，无法容纳源字符串 “Hello!” 的长度，所以会导致缓冲区溢出问题，可能导致程序崩溃或产生不可预知的行为。

正确的做法是要确保目标字符串具有足够的空间来存储源字符串，可以使用 strncpy 函数代替 strcpy 函数，并指定要复制的最大字符数，以避免缓冲区溢出问题。例如：

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

int main(void) {
    char src[10] = "Hello!";
    char dest[5];

    // 使用 strncpy 函数将 src 中的字符串复制到 dest 中
    strncpy(dest, src, sizeof(dest)-1);
    dest[sizeof(dest)-1] = '\0';

    printf("src: %s\n", src);
    printf("dest: %s\n", dest);

    return 0;
}

使用 strncpy 函数时，我们指定要复制的最大字符数为 sizeof(dest)-1，这样可以保证在复制字符串时不会超出 dest 的大小。另外，由于 strncpy 函数不会自动在目标字符串末尾添加 ‘\0’ 字符，所以需要手动将其添加到 dest 的末尾. 以上是面试中经常被问。

如果您喜欢今天的文章，请不要忘记在下方留言并分享给您的朋友们。我将非常感激您的支持，并期待您的关注，共同探索更多有趣的话题，我是 小昭debug。

希望以上小结能够对您有所帮助！