结构体，指针嵌套内存对其位域条件编译

结构体

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


// struct 是一个C语言的一个关键字，用来声明一个结构体类型
// 声明了一个名字叫 student 的结构体类型
// 有两个成员，分别是整型的 id(学号)  字符数组 name(名字)
// struct 只是声明了这样一种数据类型，和普通的数据类型比如int、char
// 一样本身是没有分配空间的，只有在定义变量的时候才会为变量分配空间
struct student
{
int id;
char name[20];
}; //用struct 声明类型的时候要有 ；号，和函数相区分


#if 0


// 变量定义2：直接在结构类型声明的时候定义变量
struct teacher
{
int id;
char name[20];
}t1,t2;  // 定义了两个老师的变量 变量名叫 t1、t2


// 变量定义3：结构类型可以不要名字，也就是说不能在其他地方使用了
// 只能在类型声明的时候定义变量
struct 
{
int a;
int b;
}a, b;  // 定义结构体变量a和b
// 
int main()
{
// 结构体的变量定义
// 定义了一个student结构体变量 变量名叫 stu
// 用结构体定义变量的时候，类型要写完整，struct 关键字不能丢
// student stu2;  struct 不能丢
struct student stu;


return 0;
}
#endif


// 结构体变量的初始化和成员使用
int main1()
{
// 定义结构体变量并且初始化
struct student stu = {1234, "xiaoming"};

struct student stu2 = {.name="xiaohong", .id=1234};

// 结构的成员变量的使用，结构变量使用成员变量，需要点 . 指明使用的是哪一个成员
printf ("id = %d, name = %s\n", stu.id, stu.name);

}


int main()
{
struct student stu;

// 结构体变量使用
stu.id = 1224;
strcpy(stu.name, "hello");

printf ("id = %d, name = %s\n", stu.id, stu.name);

}

结构体的内存对齐

#include <stdio.h>


struct A
{
char ch1;
char ch2;
};




struct B
{
int a;
int b;
};


struct C
{
char ch1;
//char ch2;
short sh;
int a;
//char ch3;
};


struct D
{
char ch;
int a;
short sh;
char ch2;
};


struct E
{
char ch;
double d;
};


int main()
{
printf ("%d\n", sizeof(struct A));
printf ("%d\n", sizeof(struct B));
printf ("%d\n", sizeof(struct D));
printf ("%d\n", sizeof(struct E));

return 0;
}

位域

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


struct A
{
unsigned int a:4;  // 变量a 只能使用4bit的空间
unsigned int b:2;
unsigned int c:12;
};


struct B
{
unsigned int a:4;  
unsigned int b:2;
unsigned int c:30;
};


struct C
{
unsigned int  a:4;  
unsigned char b:2;
unsigned int  c:12;
};


struct D
{
unsigned int  a:4;    // 4
unsigned char b;      // 8
unsigned int  c:12;   // 12
};




int main()
{
printf ("%d\n", sizeof (struct D));
struct D a;

// 将变量a所占的内存空间赋值为0
memset (&a, 0, sizeof(struct D));

a.a = 1;
a.b = 1;
a.c = 1;

int *p = (int *)&a;

printf ("%d\n", *p);

return 0;
}


int main3()
{
printf ("%d\n", sizeof (struct C));
struct C a;

// 将变量a所占的内存空间赋值为0
memset (&a, 0, sizeof(struct C));

a.a = 1;
a.b = 1;
a.c = 1;

int *p = (int *)&a;

printf ("%d\n", *p);

return 0;
}


int main2()
{
printf ("%d\n", sizeof (struct B));

struct B a;
memset (&a, 0, sizeof(struct B));
a.a = 1;
a.b = 1;
a.c = 1;
int *p = (int *)&a;

printf ("%d\n", *p);



return 0;
}


int main1()
{
//printf ("%d\n", sizeof (struct A));
struct A a;

// 将变量a所占的内存空间赋值为0
memset (&a, 0, sizeof(struct A));

a.a = 1;
a.b = 1;
a.c = 1;

int *p = (int *)&a;

printf ("%d\n", *p);


return 0;
}

结构体嵌套

#include <stdio.h>


struct A
{
char ch;
int a;
};


struct B
{
char ch;
struct A a;
};




int main()
{
printf ("%d\n", sizeof(struct B));

return 0;
}

结构体指针

#include <stdio.h>
#include <string.h>
struct student
{
int id;
char name[20];
};


int main1()
{
// 定义了一个结构体变量
// 结构体变量名和数组名进行区分
// 数组名代表数组首个元素的地址
// 结构体变量是一个变量不是地址
struct student stu; 

// 定义了一个结构体变量指针
struct student *p = &stu;

// 通过指针使用结构体变量：需要新的运算符->
// ->只是用在结构体指针变量引用成员变量的时候
p->id = 10;   // stu.id = 10;
strcpy(p->name, "abcd");

printf ("id = %d, name = %s\n", p->id, p->name);

return 0;
}




void printA(struct student a)
{
a.id = 5678;
printf ("id = %d, name = %s\n", a.id, a.name);
}




void printB(struct student *a)
{
a->id = 5678;
printf ("id = %d, name = %s\n", a->id, a->name);
}




int main()
{
struct student a = {1234, "hello"};
struct student b;
b = a;// 结构体变量之间可以直接赋值

// 结构体变量之间可以直接赋值导致结构变量可以直接作为函数参数进行传递
printB(&b);
printf ("id = %d, name = %s\n", b.id, b.name);

return 0;
}

共用体

#include <stdio.h>


// union是C语言的关键字，用来声明一个共用体类型
union A
{
char ch;
int a;
};


int main()
{
union A a;
a.a = 5;
a.ch = 1;

printf ("%p, %p, %p\n", &a, &a.a, &a.ch);

//printf ("%d\n", a.a);

//printf ("%d\n", sizeof(union A));

unsigned int b = 0x12345678;
char *p = (char *)&b;

printf ("%x\n", *p);
printf ("%x\n", *(p+1));
printf ("%x\n", *(p+2));
printf ("%x\n", *(p+3));


    return 0;
}


判断大小端

#include <stdio.h>


// 小端返回真（1），大端返回假（0）
int isLittleEndian()
{
union
{
char ch;
int a;
}a;

a.a = 1;
return (a.ch == 1);
}


int main()
{
if (isLittleEndian())
printf ("小端\n");
else
printf ("大端\n");

return 0;
}

枚举

#include <stdio.h>


// enum 是C语言的一个关键字，用来声明枚举类型
enum week{ Mon = 10, Tues, Wed, Thurs = 1000, Fri, Sat, Sun };


int main()
{
// 定义一个枚举变量
// 枚举变量day 的取值范围是 week定义的这些常量中的一个
// 没有day.Mon 的形式
enum week day;
day = Mon;
// 枚举定义出来的是一个常量，值不能被改变
// Mon = 8;

printf ("%d\n", Sat);

printf ("%d\n", sizeof(day));

return 0;
}

宏定义

#include <stdio.h>


#define PI 3.1415926


void func()
{
// 宏没有局部的说法，一旦定义，如果没有销毁，就可以一直使用
#define STR  "hello"
}






int main1()
{
printf ("%f\n", PI);

// 宏的撤销
//#undef STR  
printf ("%s\n", STR);
return 0;
}


// 宏函数，使用方式类似函数，但跟函数是有本质区别的
//#define MUL(a, b)  a*b
#define MUL(a, b)  ((a)*(b))


#define MIN(a, b)   (((a)>(b))?(b):(a))


#define SIZE(a)  sizeof(a)/sizeof(a[0])


int func1(int a[])
{
printf("代码在 %d 行\n", __LINE__);
printf("代码编译的时间%s %s\n", __DATE__, __TIME__);
printf("文件名 %s\n", __FILE__);
printf("函数名%s\n", __FUNCTION__);
return sizeof(a)/sizeof(a[0]);
}


int main()
{
int a[10];

printf ("%d\n", SIZE(a));
printf ("%d\n", func1(a));
return 0;
}


int main2()
{
int a = 10;
int b = 20;


int c = MUL(a, b);

int d = MUL(MUL(a+b, b)+a, b);


MIN(a++, b);
printf ("a = %d\n", a);

printf ("%d\n", d);

return 0;
}



条件编译

#include <stdio.h>
 
int main()
{
  #ifdef _DEBUG
     printf ("正在使用DEBUG模式编译代码。。。\n");
  #else
     printf ("正在使用Release模式编译代码。。。。\n");
  #endif
 
  return 0;
}

typedef关键字

#include <stdio.h>


// typedef 用于给本来存在的类型重新起个名字
typedef int INT;


// 给 int [20] 这样的类型取个别名叫 ARR
typedef int ARR[20];


// 定义指针类型 PINT是int *的别名
typedef int * PINT;


struct student 
{
int id;
char name[20];
};


// STU就是 struct student 这样一种类型
typedef struct student STU;


// Node是 struct _node 这个结构体类型的别名
typedef struct _node
{
int data;
char ch;
}Node;


// PNode 是struct _node *这样结构体指针类型
typedef Node * PNode;


// PFUNC 是一个函数指针类型
typedef void (*PFUNC)(int, char**);


void myMain(int count, char **argv)
{

}
// void (*p)(int, char**) = myMain;
PFUNC p = myMain;


void func(PFUNC p)
{

}




int main()
{
struct student stu;
STU stu1;

// 定义一个 struct _node 类型的结构体变量
Node node;

// pnode 是一个指针
PNode pnode;
printf ("pnode = %d\n", sizeof(pnode));

return 0;
}


int main1()
{
int a,b;

// 定义两个int型变量
INT c,d;

// a1, a2都是 int [20] 这样一个数组类型
ARR a1, a2;

printf ("a1 = %d, a2 = %d\n", sizeof(a1), sizeof(a2));

// p1, p2 都是int *类型的指针
PINT p1, p2;


return 0;
}