练习与注意事项：
1.结构体
struct student {
char name[20];
int age;
BOOL gender;
};
- 结构体要定义在main()函数之外
2.类型重定义，将一个数据类型的名称再起另一个名字，以后再定义这个类型的变量的时候可以使用别名作为类型，方便书写
typedef struct teacher{
char name[20];
int age;
}Teacher;
typedef int nihao;
void change(int *a);
3.main()函数进行实现：
struct student stu1 = {"zhangsan", 18, YES};
printf("name = %s\n",stu1.name); //结构体的访问方式
printf("age = %d\n",stu1.age);
struct student stu2 = {"lisi",30, NO};
//修改成员变量
stu2.gender = YES;
strcpy(stu2.name, "lis");
printf("修改后的名字：%s\n",stu2.name);
Teacher teacher = {"帅哥\n",1};
printf(teacher.name,teacher.age);
4.数组
//取内容运算符：*
int b = 10;
change(&b);
printf("%d", b);
char str[20];
scanf("%s",str); //数组不需要&符号，数组不是指针
int array[10] = {0};
printf("array -> \t%p\n",array);
printf("&array -> \t%p\n",&array);
printf("array -> \t%p\n",array + 1);
printf("&array + 1 -> \t%p\n",&array + 1);
5.冒泡排序回顾
int a[] = {1,2,3,4,5,6,7,8,9,10,11,12,84,15,97,23,75,87,345,93};
int *p1 = a;
BOOL f = YES;
for (int j = 0; j < 20; j++) {
f = NO;
for (int i = 0; i < 20 - 1 - j; i++) {
if (*(p1 + i) > *(p1 + i + 1)) {
int temp = *(p1 + i + 1);
*(p1 + i + 1) = *(p1 + i);
*(p1 + i) = temp;
f = YES;
}
}
}
for (int i = 0; i < 20; i++) {
printf("%d",*(p1 + i));
}
6.静态变量
for (int i = 0; i < 10; i++) {
//静态变量只能被初始化一次
static int n = 10;
printf("%d\n",n);
n++;
}
7.在堆内存申请8个字节的内存空间，并将该空间的首地址返回，将该地址赋值给char型指针
char *str = malloc(8);
strcpy(str, "iPhone");
printf("%s\n",str);
free(str);
8.内存标记已经清除，再次通过该指针访问这块内存空间可能会发生错误，这种错误我们叫野指针错误
printf("%s\n",str);
int *num = malloc(sizeof(int));
*num = 4;
printf("%d",*num);
9.内存溢出 内存泄露
free(num);
10.防止野指针错误
num = NULL;
//printf("%d\n",*num);
知识点：
1.结构体的嵌套
struct car {
char carName[20];
int carNum;
};
typedef struct car Car;
struct person {
char name[20];
Car car;
};
2.结构体嵌套时，应注意避免使用结构体本身， 如下写法是错误的：
struct person {
char name[20];
struct person per;
};
3.指针：
与指针相关的概念：
1️⃣内存地址：编号对应的内存以字节为单位划分。
2️⃣内存地址的大小：32位操作系统占4字节，64位操作系统占8个字节。
3️⃣指针变量：特指存储内存地址的变量。
4️⃣指针变量的算数运算：指针不是类型，真正的类型是地址，指针（指针变量）是指存储地址这种数据类型的数据的变量。
5️⃣指针变量的数据类型：指针变量的数据类型只限定了指针在参与算数运算的时候一次偏移多少个字节，通过＊取内容的时候读取多少个字节。
6️⃣静态存储器
7️⃣malloc内存分配函数分配
8️⃣动态内存分配：
void *malloc(unsigned int aize);
void *：泛型，可以代表所有的指针类型。
作业：
1.定义Person结构体，成员变量为姓名，年龄，性别，定义三个该结构体的变量，定义函数，打印年龄最小的那个人的姓名
typedef struct person{
char name[20];
int age;
BOOL gender;
}Person;
//比较的人少的情况
void yoursAge(Person p1, Person p2, Person p3){
Person minP = p1.age < p2.age ? p1 : p2;
Person minFP = minP.age < p3.age ? minP :p3;
printf("年龄最小的是：%s\n",minFP.name);
}
//人多的情况(数组形式)
void findMinAgePersonByArray(Person pArr[], int count){ //数组和数组长度
if (count > 0) {
Person minAgeP = pArr[0];
for (int i = 1; i < count; i++) {
if (minAgeP.age > pArr[i].age) {
minAgeP = pArr[i];
}
}
printf("%s\n",minAgeP.name);
}
}
void yoursAge(Person t1, Person t2, Person t3);
void findMinAgePersonByArray(Person pArr[], int count);
int main(int argc, const char * argv[]) {
Person p1 = {"张三", 30, YES};
Person p2 = {"李四", 28, NO};
Person p3 = {"王五", 25, YES};
yoursAge(p1,p2,p3);
Person pArray[] = {p1, p2, p3};
findMinAgePersonByArray(pArray, sizeof(pArray) / sizeof(Person));
return 0;
}
2.输入一个数组长度,动态创建数组存储整数,所有元素为随机生成[10,30]之间的数,输出元素中的最大值。
int main(int argc, const char * argv[]) {
int count = 0;
printf("输入数组长度：");
scanf("%d",&count);
int *array = malloc(sizeof(int) * count);
int max = 0;
for (int i = 0; i < count; i++) {
array[i] = arc4random() % (30 - 10 + 1) + 10; //array[i] = *(array + i)两个等价
printf("随机数为：%d\n",array[i]);
if (max < array[i]) {
max = array[i];
}
}
printf("最大值为：%d\n",max);
return 0;
}
3.编写函数swap交换两个在堆空间存储的浮点数的值
void swap(float *a, float *b){
float t = *b;
*b = *a;
*a = t;
printf("交换后的两个值为：%f,%f\n",*a, *b);
}
void swap(float *a, float *b);
int main(int argc, const char * argv[]) {
float *a = malloc(sizeof(float));
float *b = malloc(sizeof(float));
*a = 10;
*b = 20;
swap(a, b);
free(a);
a = NULL;
free(b);
b = NULL;
return 0;
}
