你能在函数中返回一种指向指针的指针吗？

Question

I know you can return a type of pointer from a function. ex. void *foo() Can you return a type of pointer to pointer in a function? ex. void **foo2()

Here is more info about my question:

I try to assign a ptr-to-ptr, tmp2, to blocks[i][j], and then return tmp2. blocks[i][j] is a ptr-to-ptr as well.

I'm confused to manipulate a ptr to a ptr-to-ptr: I am not sure if return ((tmp2+i)+j); is the cause of the segmentation fault at line printf("2---%d\\n", **tmpPtr2); . To debug, I try to print: printf("%d\\n", *( (*(tmp2+i)) +j) ); However, it causes a new segmentation fault.

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

int **blocks, **tmp2;
int n = 10;

int **findBlock2(int b){
    int i, j ;

    for (i=0; i<n; i++){
        for (j=0; j<n; j++){
            if (blocks[i][j]==b){
                printf("%d\n", blocks[i][j]);

                //Segmentation fault
                printf("%d\n", *((*(tmp2+i))+j) );

                return ((tmp2+i)+j);
            }
        }
    }
    return NULL;
}

int main(int argc, const char * argv[]) {
    int i, j;
    int **tmpPtr2;

    //allocate memory space and assign a block to each index
    blocks=malloc(n * sizeof *blocks);
    for (i=0; i<n; i++) {
        blocks[i]=malloc(n * sizeof(*blocks[i]));
        blocks[i][0]=i;
    }

    if ((tmpPtr2=findBlock2(4))==NULL)    return -1;

    //Segmentation Fault
    printf("2---%d\n", **tmpPtr2);

    return 0;
}

Update to answer my question:

(1) Adding t tmp2=blocks; to the top of findBlock2() removed both segfaults.

(2) return ((tmp2+i)+j); shows how to manipulate a ptr-to-ptr pointing to a ptr-to-ptr or a 2D array

(3) printf("%d\\n", *( (*(tmp2+i)) +j) ); shows how to do (2) and dereference it.

Hope it helps others

Answer 1

Yeah, just like you would with any pointer variables.

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

int ** function(){
    int ** matrix = malloc(sizeof(int*));
    *matrix = malloc(sizeof(int));
    matrix[0][0] = 5;
    return matrix;
}

int main()
{
    int **matrix = function();
    printf("%d",matrix[0][0]);
    free(matrix[0]);
    free(matrix);
    return 0;
}

Adding to the other part. In your function findBlock2 besides accessing an invalid reference that has already been pointed out, it seems that your objective is to return a reference to the block that fulfills if statement. If that is the case then returning a pointer to int* should suffice.

int *findBlock2( int b )

/////////////////

return ( *(blocks+i)+j );

Answer 2

The answer is "yes". Please refer the following code:

#include <stdio.h>
#include <malloc.h>

void ** foo2(void){
    int **p = malloc(sizeof(*p));
    return (void**)p;
}

int main(void) {
    printf("%p\n", foo2());
    return 0;
}

The result is (in my 32-bit platform):

0x80e9008

Answer 3

You probably want a 2D array at not some slow, fragmented lookup table. In that case, do like this:

#include <stdlib.h>

void* alloc_2D (size_t x, size_t y)
{
  return malloc (sizeof (int[x][y]));
}

int main (void)
{
  const size_t X = 5;
  const size_t Y = 3;

  int (*arr_2D)[Y] = alloc_2D(X, Y); 

 // X dimension was omitted in declaration to make array syntax more intuititve:

  arr_2D[i][j] = something;

  ...
  free(arr_2D);
}