黑马程序员--IOS基础第十三天（C语言）



1.
结构体数组：

用来存放大量的结构体相同的结构体变量.结构数组的每一个元素都是具有相同结构类型的下标结构变量

结构体数组定义:

定义格式：

Struct 结构名{

成员表列

}数组名][数组长度]；

结构体数组定义的第一种方式：

1）定义结构体的同时，定义数组

struct Student{

int age;

char *name;

int s_no;

float score;

}stu[5];

2）先定义结构体，后定义数组

struct Student boy[5];

#include
<stdio.h>

int main(int
argc, const
char * argv[]) {

struct Student{

int age;

char *name;

int s_no;

float score;

}stu[5];

struct Student boy[5];

return 0;

}

2.结构化数组的初始化和遍历

#include
<stdio.h>

void test1(){

//结构体数组的初始化方法

//1、定义结构体数组的时候，进行初始化

struct Student{

char name[20];

int age;

}boys[3]={{"sb",18},{"zbz",38},{"cgx",28}};

//2、定义的同时进行初始化

struct Student girls[2]={{"fengjie",18},{"cjk",28}};

//3、先定义后初始化,整体赋值

struct Student ds[2];

ds[0]=(struct Student){"xzmly",18};

ds[1]=(struct Student){"bdjy",18};

//4、先定义结构体数组，后初始化

struct Student stu[2];

//stu[0].name = "zhangsan";

//strcpy(stu[0].name,"zhangsan");

scanf("%s",stu[0].name);

stu[0].age = 19;

//
char ch[10];

// scanf("%s",ch);

//2、结构数组的遍历**********

for(int
i=0;i<3;i++){

printf("name:%s,age:%d\n",boys[i].name,boys[i].age);

}

}

int main(int
argc, const
char * argv[]) {

//结构体

struct stu{

int num;

char *name;

char sex;

float score;

};

//1、定义结构体数组

struct stu boy[5]={

{101,"Li
ping",'F',45},

{102,"Zhangping",'M',62.5},

{103,"He
fang",'F',92.5},

{104,"Chengling",'M',87},

{105,"Wangming",'M',58}};

//2、有一个循环

//

float sum = 0.0f;

int count=0;
//保存不及格的人数

for (int
i=0; i<5; i++) {

//
计算总成绩

sum+=boy[i].score;

//
判断成绩是否小于60
，如果小于了60 要让计算器+1

if(boy[i].score<60) {

count++;

}else
if(boy[i].score>=80 && boy[i].score<=100){

//
判断是否大于80小于100

//
如果在这个区间，应该输出姓名和成绩

printf("姓名：%s，成绩:%.2f\n",boy[i].name,boy[i].score);

}

}

printf("平均值：%.2f\n",sum/5);

printf("不及格人得个数：%d\n",count);

return 0;

}

3.结构指针定义和初始化

1、什么是结构体指针？

用来存放结构体变量地址的指针变量。结构指针变量中的值是所指向的结构体变量的首地址。

2、结构体指针定义

struct 结构体名 *指针变量名;

//定义一个结构体

struct Car{

int lunzi;

int speed;

}car1;

struct Car *p=NULL; //定义一个结构体指针变量

p = &car1;//正确的

p = &Car;//错误的

*/

#include
<stdio.h>

int main(int
argc, const
char * argv[]) {

//定义一个结构体

struct Car{

int lunzi;

int speed;

}car1;

//定义一个结构体指针

struct Car *p=NULL;
//定义一个结构体指针变量

p = &car1;//正确的

//p = &Car;//错误的

//结构体名：Car

//结构体变量名 car1

//结构体指针: p

return 0;

}

4.结构体指针间接访问成员值

1、结构体变量的成员值

struct Student{

int age;

char *name;

};

//定义一个结构体的变量

struct Student stu1={18,"张三丰"};

//结构体变量的成员值有2个

// stu1.age 值 18

// stu1.name 值 张三丰

2、用结构体指针间接的访问结构体变量的成员值

//

struct Student *p = &stu1;

//使用p 获取 18
张三丰

有两种方法：

1） (*p).age
访问年龄 (*p)--->stu1

(*p).name 访问姓名

2) p->age 访问的年龄

p->name 访问的是姓名

注意：p一定是一个结构体指针

stu1->name; //错误的

#include
<stdio.h>

int main(int
argc, const
char * argv[]) {

struct Student{

int age;

char *name;

};

//定义一个结构体的变量

struct Student stu1={18,"张三丰"};

//结构体变量的成员值有2个

// stu1.age
值18

// stu1.name
值 张三丰

// 2、用结构体指针间接的访问结构体变量的成员值

//

struct Student *p = &stu1;

printf("姓名：%s,年龄:%d\n",(*p).name,(*p).age);

printf("姓名：%s,年龄:%d\n",p->name,p->age);

return 0;

}

5.
结构体的嵌套：

结构体定义中，结构体的成员又是另外一个结构体变量

结构体的嵌套的注意事项：

1）结构体定义中可以嵌套其他结构体类型的变量

不可以嵌套自己这个类型的变量

struct Date{

int month;

int year;

int day;

};

struct Student {

char *name;

int age;

float score;

struct Student stu; //错误的

}

2）可以嵌套自己类型的指针

#include
<stdio.h>

//定义了一个时间的结构体

struct Time{

int hour;

int min;

int sec;

};

//定义一个Date的结构体

struct Date{

int year;

int month;

int day;

//嵌套Time的结构体

struct Time time;

};

//定义了一个学生的结构体

struct Student {

char *name;

int age;

float score;

struct Date birthday;

//struct Student stu; //错误的

//struct Student *stu; //正确的

};

int main(int
argc, const
char * argv[]) {

//1、嵌套的结构体如何进行初始化

struct Student stu1={"张三丰",28,59.99f,{1200,2,14,{12,12,12}}};
//定义了一个结构体变量

//2、嵌套的结构体如何进行访问

printf("姓名：%s，年龄:%d(生日:%d-%02d-%02d),成绩:%.2f\n",stu1.name,stu1.age,stu1.birthday.year,stu1.birthday.month,stu1.birthday.day,stu1.score);

//访问时间

printf("姓名：%s，年龄:%d(生日:%d-%02d-%02d
%02d:%02d:%02d),成绩:%.2f\n",stu1.name,stu1.age,stu1.birthday.year,stu1.birthday.month,stu1.birthday.day,stu1.birthday.time.hour,stu1.birthday.time.min,stu1.birthday.time.sec,stu1.score);

//3、结构体嵌套自身的指针

struct Person {

char *name;

int age;

//嵌套自己类型的指针

struct Person *child;

};

//结构体嵌套自身指针的，初始化

//定义kim

struct Person kim={"kim",8,NULL};

//struct Person *child = &kim;

struct Person p1={"林志颖",38,&kim};

//结构体嵌套自身指针的，访问

printf("%s
的儿子是:%s，儿子的年龄：%d\n",p1.name,p1.child->name,p1.child->age);

return 0;

}

6.结构体变量及成员作为函数参数

成员值做函数的参数：结构体成员属性作为函数的参数就是值传递（成员变量是数组除外）

结构体变量名作为函数的参数：

在ANSI C标准中允许用结构变量作函数参数进行整体传送。但是这种传送要将全部成员逐个传送，特别是成员为数组时将会使传送的时间和空间开销很大，严重降低了程序的效率。因此最好的办法就是使用指针，即用指针变量作函数参数进行传送。这是由实参传向形参的只是地址，从而减少了空间和时间的开销。

#include
<stdio.h>

struct Car{

int lunzi;

int speed;

};

void xiuche(int
n){

n = 2;

}

//用结构体变量作为函数的参数

void xiuche1(struct
Car c1){

c1.lunzi = 2;

}

int main(int
argc, const
char * argv[]) {

//定义一个结构体变量

struct Car car1={4,200};

//car1.lunzi
结构体变量成员值
4

//1、用结构体变量的成员值作为函数的参数，实质是值传递

xiuche(car1.lunzi);

//2、用结构体变量作为函数的参数

//实质上还是值传递

xiuche1(car1);

printf("%d\n",car1.lunzi);
//4

return 0;

}

7.结构指针作为函数的参数

#include
<stdio.h>

struct Car{

int lunzi;

int speed;

};

/**

*
结构体指针作为函数的参数

*

* @param c1
是一个结构体指针

*/

void xiuche2(struct
Car *c1){

c1->lunzi = 2;

}

int main(int
argc, const
char * argv[]) {

//定义一个结构体变量

struct Car car1={4,200};

//注意：用结构体变量的地址传递给函数

//
也可以理解为用结构体指针作为函数的参数

//
实质：是地址传递

xiuche2(&car1);

printf("%d\n",car1.lunzi);
//2

return 0;

}

8.学过的类型：基础数据类型、指针、空类型
void、构造类型（数组、结构体）、定义类型

9.枚举类型（是一种基本数据类型，而不是一种构造类型，因为它不能再分解为任何基本类型）

C语言提供了一个种类型，这种类型的变量的取值被限定在一定的范围之内了

枚举类型的定义：

enum 枚举类型名{ 枚举值1,枚举值2,.... };

举例：

定义一个变量，保存一周的第几天

enum weekday{zhouyi,zhouer,zhousan,zhousi,zhouwu ,zhouliu,zhouri };

定义iPhone手机的颜色

关于枚举类型元素的命名习惯

enumiColor{kIcolorWhite,kIcolorBlack,kIcolorTHJ};

定义人得性别

enum Sex{kSexMan,kSexWomen,kSexYao};

//weekday iColor Sex 这些都是枚举类型

*/

#include
<stdio.h>

//全局的枚举类型

enum Sex{kSexMan,kSexWomen,kSexYao};

int main(int
argc, const
char * argv[]) {

//定义局部的枚举类型

enum weekday{ zhouyi,zhouer,zhousan,zhousi,zhouwu,zhouliu,zhouri
};

enum iColor{kIcolorWhite,kIcolorBlack,kIcolorTHJ};

return 0;

}

10.枚举类型变量

枚举类型的变量

枚举类型的变量的定义

enumiColor{kIcolorWhite,kIcolorBlack,kIcolorTHJ};

1）先定义枚举类型，再定义枚举变量

enum 枚举类型名 枚举变量名列表；

enum iColor iPhoneColor; //iPhoneColor的取值是有要求的

//取值应为kIcolorWhite,kIcolorBlack,kIcolorTHJ中的其中一个

2）定义枚举类型的同时，定义变量

enum Sex{kSexMan,kSexWomen,kSexYao}isex;

*/

#include
<stdio.h>

//默认值
0 1 2

//手动赋值
5 6 7

enumiColor{kIcolorWhite=5,kIcolorBlack,kIcolorTHJ};

int main(int
argc, const
char * argv[]) {

//1、枚举类型变量的定义

enum iColor iPhoneColor;
//iPhoneColor的取值是有要求的

//取值应为kIcolorWhite,kIcolorBlack,kIcolorTHJ中的其中一个

enum Sex{kSexMan,kSexWomen,kSexYao} isex;

//2、枚举类型变量的初始化

//给枚举变量赋值

iPhoneColor = kIcolorTHJ;

isex = kSexYao;

//3、枚举变量如何使用

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

//4、枚举变量的值

//枚举类型定义完成以后，系统会自动给枚举的每个元素都会赋值一个整形的初值

//
默认初值：从第一个元素开始值为0，以后个元素的值，是上一个元素的值+1，

//

//5、应用

struct Person{

char *name;

//char sex; //'z'

enum Sex isex;
//kSexMan,kSexWomen,kSexYao

};

//6、不按套路的出牌

iPhoneColor = 3.4; //尽量不要这么干

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

return 0;

}

11.typedef关键字：

typedef就是给数据类型取“别名”

定义一般类型：

typedef
原类型名
新类型名；

其中原类型名中含有定义部分，新类型名一般用大写表示，以便于区别。

有时也可用宏定义来代替typedef的功能，但是宏定义是预处理完成的，而typedef则是在编译时完成的，后者更为灵活。

#include
<stdio.h>

int main(int
argc, const
char * argv[]) {

//typedef就给给别人起外号

int a = 10;

printf("%d\n",a+10);

//给int起个别名

typedef
int MALATANG;
//typedef语句要以分号结束

//用别名定义了一个新的变量 qiezi

MALATANG qiezi = 3;

MALATANG *p = &qiezi;

printf("%d\n",qiezi+100);

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

return 0;

}

12.typedef的使用方法：

#include
<stdio.h>

int sum(int
a,int b){

return a+b;

}

int jian(int
a,int b){

return a-b;

}

int main(int
argc, const
char * argv[]) {

//1、基本数据类型

typedef
int
MALATANG;

//2、用在数组，给数组起别名

typedef
int
ARRAY[5]; //int a[5];
数组长度为5

ARRAY a1={1,2,3,4,5},b1={5,4,3,2,1}; //int a1[5],b1[5];

for (int
i=0; i<5; i++) {

printf("%d\t",b1[i]);

}

//3、给结构体其别名

struct Person {

char *name;

int age;

};

printf("\n");

struct Person p1={"zbz",18};

//给 struct Person
起个别名 P

typedef
struct Person P;

//用别名定义新的变量

P p2 = {"xzmly",28};

printf("name:%s,age:%d\n",p2.name,p2.age);

//给结构体定义别名2

typedef
struct Car {

int lunzi;

int speed;

}MYCAR; //表示把结构体起个别名 MYCAR

MYCAR car1={1,200};

//给匿名的结构体起个别名

typedef
struct {

int screenSize;

int ram;

}IPHONE;

//用新类型定义结构体变量

IPHONE iphone7Plus={10,8};

//4、给枚举类型起别名

//

typedef
enum Sex{kSexMan,kSexWomen,kSexYao} ISEX;
//ISEX别名

//WEEKDAY也是别名

typedef
enum {zhouyi,zhouer,zhousan,zhousi} WEEKDAY;

//给枚举类型起个别名 S

typedef
enum Sex S;

S s1,s2;

s1 = kSexYao;

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

//5、给函数指针

//指向函数的指针

int (*p)(int,int);
//函数指针

//给函数中指针其别名

typedef
int (*FUN)(int,int);
//FUN是一个别名

FUN f1,f2; //f1和f2都是函数指针

f1 = jian;

printf("%d\n",f1(61,23));

return 0;

}

14.预处理指令：以#开头的都是预处理指令。在源程序中这些命令都放在函数之外，而且一般都放在源文件前面，它们称之为预处理指令。

预处理：在进行编译的第一遍扫描（词法扫描和语法分析）之前所作的工作。

15.c语言提供预处理功能，如宏定义、文件包含、条件编译等。

16.宏的概念及无参宏定义方法

宏：

C语言中我们自定义的特殊标示符，习惯大写

宏的定义：

#define 宏名 宏字符串（可以是常量、变量、表达式）

注意：预处理指令，经常写在函数之前

宏不是一个语句，是一个预处理指令，所以不需要加分号结束

3、宏替换

源程序在编译之前，由预处理程序对我们写的源代码进行处理：会把源代码中所有出现 宏名 的地方一律使用 宏的字符串 去替换

4、注意事项：

（1）习惯上红名用大写字母表示，以便于与变量区别，但也允许用小写字母

（2）宏定义是用宏名来表示一个字符串，在宏展开时又以该字符串取代宏名，这只是一种简单的代换，字符串中更可以含任何字符，可以是常量，也可以说表达式，预处理程序对它不做任何检查。如有错误，只能在编译已被展开后的源程序时发现

（3）宏定义不是说明或语句，在行末不必加分号，如加上分号则连分号一起置换

（4）宏定义必须写在函数之外，其作用域为宏定义命令祈祷源程序结束。如要终止其作用域可使用#undef命令。

*/

#include
<stdio.h>

#define M 10

#define M1 y*y+3*y

#define R 4

#define PI 3.14

#define AREA PI*R*R
//嵌套定义

#define INT1
int

#define P
struct Person

void test(){

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

}

//#undefM
//此处的作用是，取消宏定义

void test1(){

printf("test1 =%d\n",M);

}

int main(int
argc, const
char * argv[]) {

int a[M+2];
//int a[12]

printf("%d\n",M);
//把M的值打印出来

int y = 3,result=0;

result = 3*M1+2*M1-50;

//错误的

// 3*(y*y+3*y)+2*(y*y+3*y)-50;

//
54 +36 -50;

//
40

//正确的

// 3*y*y+3*y+2*y*y+3*y-50;

//
27 +9 +18
+ 9 -50;

//
13

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

//宏使用的注意事项

//1、宏是有作用域的
#undef 宏名 可以取消宏定义

test();

test1();

//2、在字符串中出现的宏名不会被替换

//3、宏可以嵌套定义

printf("%.2f\n",AREA);

//4、使用宏其别名

INT1 a1;

a1 = 10;

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

P{

int age;

};

P p1 = {23};

return 0;

}

17.
有参宏的定义和使用方法

宏的分类：

无参宏 #define M 10

有参宏 #define SUM(a) a+a

对带参数的宏，在调用中，不仅要宏展开，而且要用实参去代换形参。

SUM(3) //不仅要a+a替换，而且还要把 实参3代入到 字符串中

注意事项：

（1）宏的形参之间可以出现空格，但是宏名和形参之间不能出现空格

（2）在带参宏定义中，形式参数不分配内存单元，因此不必做类型定义，而宏调用中的实参有具体的值，要用他们去代换形参，因此必须做类型说明。这是与函数中的情况不同的。在函数中，形参和实参是两个不同的量，各有自己的作用域，调用时要把实参赋予形参，进行“值传递”。而在带参宏中，只是符号代换，不存在值传递的问题。

（3）在宏定义中的形参是标识符，而宏调用中的实参可以是表达式

（4）在宏定义中，字符串内的形参通常要用括号括起来以避免出错，

（5）可以用宏定义多个语句

*/

#include
<stdio.h>

#define SUM(a) a+a

#define M1(x
,y) (x)*(y)+(x)+(y)

#define M2(a) a+3*y

#define M3(m,n) m =a+2;n=a*2;

int main(int
argc, const
char * argv[]) {

int result = SUM(3);
//6

//有参宏使用

result = M1(4, 5); //29

int y = 2;

//有参宏使用

result = M2(3); //9

//有参宏的使用注意事项

//1、宏的形参之间可以出现空格，但是宏名和形参之间不能出现空格

int a = 3;

//2、有参宏宏的参数最好用括号括起来

result = M1(a+3, a-1);

//(x
,y) x*y+x+y

//
6*2 +6+2

// 20

//
a+3*a-1+a+3+a-1

//
a+9 -1+a+3+a-1

//
3+9-1+3+3+3-1

//
19

int i,j;

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

printf("i=%d,j=%d\n",i,j);

//3、可以用宏来定义多个语句

M3(i, j);

printf("i=%d,j=%d\n",i,j);

return 0;

}

18.#define和typedef的区别：

宏定义只是简单的字符串代换，是在预处理完成的，而typedef是在编译时处理的，它不是简单的代换，而是对类型说明符重新命名，被命名的标识符具有类型定义说明的功能

19.为什么要使用条件编译：

（1）按不同的条件去编译不同的程序部分，因而产生不同的目标代码文件。有利于程序的移植和调试

（2）条件编译当然也可以用条件语句来实现。但是用条件语句将会对整个源程序进行编译，生成的目标代码程序很长，而采用条件编译，则根据条件只编译其中的程序段1或程序段2，生成的目标程序较短

条件编译：

发生在预处理阶段，在编译之前做的事情

核心:根据条件编译指定的代码

条件不同，编译的部分也不同，生成的目标文件（.o)大小也不一样

#if=#else条件编译指令：

第一种形式格式：

#if常量表达式

程序段1

#elif

代码段3

#else

程序段2

#endif

注意：忒傲剑编译后面的条件表达式中不能识别变量，它里面只能识别常量和宏定义

20.#ifdef条件编译指令

条件编译指令

1） #if #elif
#else #endif

2) #ifdef
用来判断某个宏是否定义

#ifdef
标识符

程序段1

#else

程序段2

#endif

3)#ifndef
条件编译指令 用来判断某个宏是不是没定义，如果没定义

格式：

#ifndef
标识符

程序段1

#else

程序段2

#endif

3

#include
<stdio.h>

#define DEBUG1 1

#define DEBUG2 0

int main(int
argc, const
char * argv[]) {

int a = 0;

//ifdef检测宏是否定义

#ifdef DEBUG1
//DEBUG
系统已经定义了这个宏了

a = 10;

#else

a = 10000;

#endif

//ifndef
检测宏是否定义
ifndef 如果没有定义

#ifndef DEBUG2

a = 100;

#else

a = -1;

#endif

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

return 0;

}