传递双指针的分段错误

Question

The following code causes segmentation fault to the pass double pointer to strcpy

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

void funcion(char ***ptr)
{
    *ptr = malloc(2 * (sizeof(char*)));
    (*ptr)[0] = malloc(5 * sizeof(char));
    (*ptr)[1] = malloc(5 * sizeof(char));
    strcpy(*ptr[0],"AAAA");
    strcpy(*ptr[1], "BBBB");
}
int main()
{
    char **p;
    funcion(&p);
    printf("%s %s\n", p[0], p[1]);
    return 0;
}

What is the difference between *ptr[1] and (*ptr)[1]?

Answer 1

One of the best ways to cement in your mind the way to handle dereferencing, is too sit down and write the same allocation routine several different ways. All allowable, but as the sound advice in the comments points out, some of the ways make more sense than others. Take your first example, you can pass the address of a pointer to pointer to char , but it may not be the best way to go. For example, you can write your funcion [sic] in the following manner,

/* called passing address of p */
void function (char ***ptr)
{
    *ptr = malloc (2 * sizeof *ptr);

    (*ptr)[0] = malloc (5 * sizeof(char));
    (*ptr)[1] = malloc (5 * sizeof(char));

    strcpy ((*ptr)[0], "AAAA");
    strcpy ((*ptr)[1], "BBBB");
}

There is no need to pass anything to your function if all of your allocation and data is contained in the function. You simply need to assign the return from the function. For example:

/* p simply assigning the address of ptr */
char **function2 (void)
{
    char **ptr = malloc (2 * sizeof *ptr);

    ptr[0] = malloc (5 * sizeof(char));
    ptr[1] = malloc (5 * sizeof(char));

    strcpy (ptr[0], "AAAA");
    strcpy (ptr[1], "BBBB");

    return ptr;
}

Since the function allocates memory for the pointers and also allocates storage for the hardcoded "AAAA" and "BBBB" values, all you need back from the function is the address for ptr which you can assign to p . You simply need to match the function type for the required return. You can then access all values from the calling function through p .

You can also look at tools available to simplify what it is you are trying to accomplish. For example strdup can both allocate and copy a string. You could further simplify function2 above as:

/* a simplified version of funciton2 */
char **function3 (void)
{
    char **ptr = malloc (2 * sizeof *ptr);

    ptr[0] = strdup ("AAAA");
    ptr[1] = strdup ("BBBB");

    return ptr;
}

Finally, whenever you allocate data, you need to preserve a pointer to the starting address for each block, so you can free the information when it is no longer in use. For your case above, a simple function (which isn't necessarily needed as a function) could be:

/* always free all allocated memory */
void free_p (char **p)
{
    free (p[0]);
    free (p[1]);
    free (p);
}

Putting that altogether in a bit of test code, you could use all 3 to accomplish the same task:

int main (void)
{
    char **p = NULL;

    function (&p);
    printf ("%s %s\n", p[0], p[1]);
    free_p (p);

    p = function2();
    printf ("%s %s\n", p[0], p[1]);
    free_p (p);

    p = function3();
    printf ("%s %s\n", p[0], p[1]);
    free_p (p);

    return 0;
}

Example Use/Output

$ ./bin/ptrp
AAAA BBBB
AAAA BBBB
AAAA BBBB

Don't forget to validate your memory use with a memory error checker (such as valgrind for Linux). They are simple to use and available for all platforms. Example:

$ valgrind ./bin/ptrp
==17888== Memcheck, a memory error detector
==17888== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==17888== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==17888== Command: ./bin/ptrp
==17888==
AAAA BBBB
AAAA BBBB
AAAA BBBB
==17888==
==17888== HEAP SUMMARY:
==17888==     in use at exit: 0 bytes in 0 blocks
==17888==   total heap usage: 9 allocs, 9 frees, 78 bytes allocated
==17888==
==17888== All heap blocks were freed -- no leaks are possible
==17888==
==17888== For counts of detected and suppressed errors, rerun with: -v
==17888== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 1 from 1)

Always confirm All heap blocks were freed -- no leaks are possible and equally important ERROR SUMMARY: 0 errors from 0 contexts .