定义结构体与分配内存

这几天在学习数据结构的时候经常会出现一个问题，就是定义了节点的结构，然后定义了指向节点的指针，但是已经定义了指针为什么就不能直接用呢，后来查了一下相关资料发现原来在新建指针的时候不会一同分配内存给他，所以会出现非常严重的错误。即为当声明一个结构体指针时，为什么还有new(C++)或者malloc（）这种语句？

问题描述:
主题：定义结构体指针时，有没有同时分配存储空间定义结构体指针时，有没有同时分配存储空间啊？
看到结构体的数组定义好以后就直接可以用了。但是结构体指针在链表中还要malloc（）申请空间。这是为什么啊？

主要针对的就是这两个问题

下面来看一个例子

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

  struct data
{
    int i;
    int j;
};

int main(void)
{
    struct data dat1; //定义一个struct data类型的变量，和int i同理。
    printf("%d\n", sizeof(struct data)); //8个字节
    printf("%d\n", sizeof(dat1));        //8个字节

    struct data* pdat1;//定义一个struct data类型的指针，和int *pi 同理。
    printf("%d\n", sizeof(pdat1));        //4个字节,就是一个指针的空间，pdat1并没有结构体变量的信息。

    pdat1 = (struct data*)malloc(sizeof(struct data)); //申请一个空间，把该空间地址给pdat1.
    printf("%d\n", sizeof(*pdat1));      //8个字节

    struct data dats1[2]; 
    printf("%d\n", sizeof(dats1));     //16个字节，两个data变量，不是data指针。
    dats1[0].i = 20;  //可以直接使用数组里面的结构体变量
    dats1[0].j = 30;
    
    struct data* dats2[2]; //指针数组，包含两个指针，而不是结构体变量
    printf("%d\n", sizeof(dats2));  //8个字节，两个指针的大小
    //dats2[0]->i = 20; //错误！还没有给dats2[0] 指针分配空间
    //dats2[0]->i = 20; //错误！还没有给dats2[0] 指针分配空间
    dats2[0] = (struct data*)malloc(sizeof(struct data)); //分配空间
    dats2[0]->i = 20; //ok
    dats2[0]->i = 20; //ok
    return 0;
}

这里用gcc-32位编译器。如果是64位编译器则会出现不同。。这我还得研究下

运行的结果是这样的

如果把注释的两句话删去就会发现是错误的，原因就是没有给指针分配内存；

如果把结构体改为

 struct data
{
    int i;
    int j;
    int x;
    int y;
};

相对应的执行结果是

从这两个地方确实可以看得出来

结构体变量分配结构体本身大小的空间，结构体指针分配4个字节，其实任何类型的指针都是分配四个字节的指针空间。

#include <stdio.h>  
#include <stdlib.h>  
 
 struct data  
{  
    int i;  
    int j;  
	double x;
};  

int main()  
{  
	int a;
	int *aa;
	int a1[3];
	int *a11[3];

	double b;
	double *bb;
	double b1[3];
	double *b11[3];

	struct data p;
	struct data *pp;
	struct data p1[3];
	struct data *p11[3];


	printf("int:\t%d\n",sizeof(a));
	printf("*int:\t%d\n",sizeof(aa));
	printf("*int所指:\t%d\n",sizeof(*aa));	
	printf("int[3]:\t%d\n",sizeof(a1));
	printf("*int[3]:\t%d\n",sizeof(a11));
	printf("double:\t%d\n",sizeof(b));
	printf("*double:\t%d\n",sizeof(bb));
	printf("*double所指:\t%d\n",sizeof(*bb));
	printf("double[3]:\t%d\n",sizeof(b1));
	printf("*double[3]:\t%d\n",sizeof(b11));
	printf("data:\t%d\n",sizeof(p));
	printf("*data:\t%d\n",sizeof(pp));
	printf("*data所指:\t%d\n",sizeof(*pp));
	printf("data[3]:\t%d\n",sizeof(p1));
	printf("*data[3]:\t%d\n",sizeof(p11));

    printf("分配了内存空间\n");

	//*aa=1;
	//*bb=1;
	//pp->i=0;
	//pp->j=1;
	//pp->x=2;
	

	aa = (int*)malloc(sizeof(int)); //申请一个空间，把该空间地址给pdat1. 
  	printf("*intmalloc:\t%d\n",sizeof(*aa));
	bb = (double*)malloc(sizeof(double)); //申请一个空间，把该空间地址给pdat1. 
  	printf("*doublemalloc:\t%d\n",sizeof(*bb));
	pp = (struct data*)malloc(sizeof(struct data)); //申请一个空间，把该空间地址给pdat1. 
  	printf("*datamalloc:\t%d\n",sizeof(*pp));

	*aa=1;
	*bb=1;
	pp->i=0;
	pp->j=1;
	pp->x=2;
	getchar();
  
    return 0;  
}  

执行的结果是

虽然用malloc之前和之后两者指向的内存空间大小是相同的，但是

定义指针的时候确实会分配，但是是随机分配的，而且这个时候指针是不能使用的，因为你不知道分配的内存在哪，有没有内容，起码需要初始化下才能用。
        而malloc后指针会指向heap上的可用空间，这样就算函数被回收，指针还是指向正确的内容，因为指针指向堆上的内容，如果没有那一句malloc，程序会报错uninitialized local variable 'p' used。

指针被声明出来是会分配内存的，但是这块内存是不能用的，你需要把指针初始化，或者用malloc在内存上声明一块可用的空间。具体到这个程序，就是先声明一个指针类型的变量，然后给他在内存上分配一块可用的空间。如果没有malloc，编译器会认为你没有把指针初始化，也没有给他分配可用空间，就会报错