基本数据类型

基本数据类型（针对32位机）

一：

Int    4B           long  long  8B

char  1B          float            4B

short  2B         double        8B

long    4B         long doutble    12B

 

二：

所有的指针类型的内存大小都是 : 4B       基于32位机  ，即有32条地址总线。

 

复合数据类型

一：

int arr[10]    系统连续分配10个Int

 

二：  自定义类型  （由基本类型组成）

  1，结构体

         a ， 结构体的定义 ： struct 名字 { 成员1类型   成员类型1名；成员2类型  成员2名；........};

 

         b  ,   结构体例子：

                   struct  student

                    {

                             int  age;

                              int  weigth;

                              char  name[10];

                               int     tel ; 

                     };

                     注意： 结构体末尾的 ” ；“ ，不能省略。

 

 

         c  ， 结构体的内存问题 ：  地址对齐问题

                      结构体的内存不是由所有的数据成员的内存的和 ，为了方便，机器的地址访问取值。

                      一般以4个字节为单元（4B =  32b   即32位机器的32地址线寻址），为结构体分配足够的内存。

                 

                      1， char   1B   地址可以奇偶开始 ；  short    2B   地址从偶地址开始； int  4B  地址从偶地址开始；  double  8B  地址从4的倍数开始；

                       2， 数据成员在结构体声明中的排列会影响结构体的内存分配。

                               例如  ：   分到的空间是不一样的

                           struct student 
                           {
                                 char name[3];
                                 char weigth[1];
                                 int     age;
                           };


                           struct student 
                           {
                               char name[3];
                               int     age;
                               char weigth[1];

                           };

 

 

 

                       3， 当结构体中出现非char型的数据成员，该结构体的实体占得地址数应该是偶数。

                       4， 结构体中占用内存最大的数据成员，决定了该结构体的对齐方式（最大对齐单元 为 4）。

 

 

              d   结构体的使用:

                        1，定义：  struct   student   st1  。

                        2， 使用：  st1.tel 

                        3， 结构体指针 ：

                                   struct    student   *st1 =  &st2;

                                    则 ：  st1 ===   & st2; 

                                              *st1 ===  st2.name;   (结构体的第一个成员变量)；

                                               (*str1).age ===  str1 -> age

 

 

 

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

struct student_info1     // the max bit of alignmenr is 4
{
	char name[14];   // 16
	int  age ;       // 4  
};

struct student_info2
{
	int age;          // 4
	char name[14];    // 16
};

struct student_info3         //  different order have different result
{
	char gender[1]; //  
	char name[3];   // 4
	int  age;       // 4
};



struct student_info4
{
	char name[3];   //  4
	int  age;	//  4
	char gender[1]; //  4
} ; 

int main(void)
{
   	struct	student_info1 st1;
   	struct	student_info2 st2 = {.name = "lisi",.age = 17};
   	struct	student_info3 st3;
   	struct	student_info4 st4;
	printf("the sizeof st1 is %d \n", sizeof(st1)); 
	printf("the sizeof st2 is %d \n", sizeof(st2)); 
	printf("the sizeof st3 is %d \n", sizeof(st3)); 
	printf("the sizeof st4 is %d \n", sizeof(st4)); 

    // how to initialize char[n] in a struct 
	strcpy (st1.name,"zhangsan");  
	st1.age = 17;
	return 0;
}

 

 

 

2 枚举     常量的别名

  a，  enum 整形常量的别名

         {

            枚举成员1 = 具体常量，

            枚举成员n = 具体常量n            //  结束时候不需要

          } ；

 

  b ,  枚举定义

           enum month_days

            { 

                   JAN = 31  ， // 可以不赋值，若不赋值 ，则第一个枚举成员，自动设为0；

                    FEB = 29 ，

                    OCT            //  若不赋值，则在上一个的基础上上 +1

            }；

 

 

 3    联合体 ：union    ： 内部使用同一块内存的复合数据类型

        a ,  定义联合体

              union info

              {

                    int   a  ;

                    char  c ;

                    double  b ;

             }

               //  联合体里面有3个成员，联合体所占得内存是占内存空间的最大的联合体成员变量决定；

 

        b ，联合体使用 （和结构体一样，要注意的是只有最后一次的写入是有用的）。  

 

 

#include<stdio.h>

union info
{
    int  a ;
    double  b ;
    char c;
};


int main (void)
{

     union info new;
     new.a = 100;
     printf(''new.a is%d,new.b is%d    ,new.c is %d",  & new.a ,&new.b,&new.c);            //     打印出来的基地址是一样的

     printf("sizeof(new)");

    new.c = 'a';        //      联合体会覆盖
    printf(''new.a is%d,new.b is%d    ,new.c is %d",  & new.a ,&new.b,&new.c);

    return 0;
}