C malloc 指向函数内部指针的指针没有给出正确的大小

Question

So I am now rewriting my fortran code in C (to use CUDA), and apparently I do not understand how to properly use malloc and pointers. I am trying to make the main function just calls to other functions, which need to malloc arrays that will then be used inside other functions. So, I am passing pointers of pointers to them as per this post: C Programming: malloc() inside another function

But the right amount of memory is not being allocated so I get segmentation faults. Here is the code:

    #include <stdio.h>
    #include <stdlib.h>
    //#include <cuda.h>
    #include <math.h>
    //#include "cublas.h"


    //datatype to match FORTRAN complex type
    typedef float real;

    typedef struct{

        int nx;
        int ny;
        int nz;
        int sz;
        int tz;

    } states;

    void set_SPB(real **,int,states **,states **,int **);
    //void set_SPB();
    int find_minimum(int a[], int n,int start);
    const real hc =197.32697,pi=3.1415927;
    int main(){

        int nmax = 2, A = 28;

         real *etemp, *fock;
         int *Ndex,*lookup,*lookup_a;

         states *channel,*SPB;


        //!generates the single particle basis to be used
        set_SPB(&etemp,nmax,&SPB,&channel,&Ndex);  

        free(etemp);
        free(Ndex);
        free(SPB);

        return 0;
    }
    void set_SPB(real **etemp,int nmax,states **SPB,states **channel,int **Ndex){

         int tot_orbs = (2*nmax+1)*(2*nmax+1)*(2*nmax+1)*4;
         int D = tot_orbs/4;
         int Nalpha =  (2*nmax+1)*(2*nmax+1)*(2*nmax+1)*9;
         real E;

         *etemp = (real*)malloc(D);
         *Ndex = (int*)malloc(D*3);
         *SPB = (states*)malloc(tot_orbs);
          printf("orbits without spin degeneracy %d \n",D);
          printf("size of etemp %ld \n",sizeof(*etemp)/sizeof(*etemp[0]));
          return;
         int i = 0;
        for(int nx =-nmax;nx<=nmax;nx++){
             for(int ny =-nmax;ny<=nmax;ny++){
                 for(int nz =-nmax;nz<=nmax;nz++){
                     E = 0.5*4.0*pi*pi*(nx*nx+ny*ny+nz*nz);
                     //printf("%d\n",i);
                     *etemp[i] = E;
                     *Ndex[0*D+i] =nx;
                     *Ndex[1*D+i] = ny;
                     *Ndex[2*D+i] = nz;
                     i+=1;

                  }
              }
         }

         return;
       }

Also I am not sure exactly if my assignments of the arrays are correct. Specifically the print to find the number of elements of that have been allocated always gives 2, when it should be D = 125.

Answer 1

I cannot believe that float and int take only 1 byte in your environment. Multiply the size to be allocated by size of their elements.

*etemp = malloc(sizeof(**etemp) * D);
*Ndex = malloc(sizeof(**Ndex) * D*3);
*SPB = malloc(sizeof(**SPB) * tot_orbs); /* not sure because this is not used */

Note that they say you shouldn't cast the result of malloc() in C .

Also note that [] operator has higher precedence than * operator, so you have to use parentheses to use the arrays.

(*etemp)[i] = E;
(*Ndex)[0*D+i] =nx;
(*Ndex)[1*D+i] = ny;
(*Ndex)[2*D+i] = nz;