dataStructureDay010801
课堂代码以及练习
值传递、地址传递、值返回、地址返回
#include
void swap(int m,int n);
void fun(int *p,int *q);
void gun(int *p,int *q);
int hun();
int *iun();
int main(int argc, const char *argv[])
{
int num=520;
int key=1314;
swap(num,key);
printf("调用swap后主函数中num=%d,key=%d\n",num,key); //还是520,1314，因为是值传递，对主函数中变量的值没有影响
fun(&num,&key);
printf("调用fun后主函数中num=%d,key=%d\n",num,key); //还是520,1314，虽然传过去的是指针，但是因为函数中交换的是接受指针的指针变量的指向，本质还是值传递，对主函数中变量的值没有影响
gun(&num,&key);
printf("调用gun后主函数中num=%d,key=%d\n",num,key); //是1314,520，传过去指针，并且函数内将指针变量指向的内容交换了，也就是对主函数中变量值进行了交换
printf("调用hun后返回值为%d\n",hun()); //返回了一个int型的数值，需要接收，否则就会消失，并且函数的返回值是右值，无法通过hun()=456这样的语句反向赋值
int *ptr = iun(); //返回值是一个int*类型的变量，需要同样数据类型的ptr接收，并且由于函数中的变量使用了static修饰，并没有被回收，依然存在
printf("iun值为%d\n",*ptr);
*iun()=555; //并且返回值是左值，因此可以直接通过这样的语句，反过来给函数中的value赋值
printf("iun值%d\n",*iun());
return 0;
}
/*************************值传递************************/
void swap(int m,int n){
int temp = 0;
temp = m;
m = n;
n = temp;
printf("m=%d ,n=%d\n",m,n);
}
/************************值传递*****************************/
void fun(int *p,int *q){
int *temp=NULL;
temp = p;
p = q;
q = temp;
printf("*p=%d,*q=%d\n",*p,*q);
}
/*********************地址传递********************************/
void gun(int *p,int *q){
int temp=0;
temp = *p;
*p = *q;
*q = temp;
printf("*p=%d,*q=%d\n",*p,*q);
}
/***********************值返回********************************/
int hun(){
int value = 666;
return value;
}
/*************************地址返回*****************************/
int *iun(){
static int value = 999;
return &value;
} 
内存分区
#include
#include
int m; //全局区的.bss段
int n = 520; //全局区的.data段
static int k; //未初始化的静态变量，全局区 .bss段
static int l = 666; //已初始化的静态变了，全局区的.data段
char arr[32]="hello world"; //arr在.data段，hello world在ro段
char *p = "hello"; //指针在.data段，“hello”在.ro段
int main(int argc, const char *argv[])
{
double b = 999.9; //局部变量在栈区申请
int a;//局部变量，在栈区申请，初始值为随机值
printf("&a=%p,&b=%p\n",&a,&b);
static int c; //静态局部变量，在全局区的.bss段申请
static int d = 520; //静态局部变量初始化，在全局区的.data段
char *q = "nihao"; //q在栈区申请的8字节，但是“nihao”在全局区的.ro段
char r[32]="hello world"; //数组在栈区申请，“hello world”在全局区的.ro段
int *ptr = (int *)malloc(sizeof(int)); //ptr在栈区，申请的空间在堆区，初始值为随机值
return 0;
} 
动态内存分配和回收（malloc、free）
#include
#include
int main(int argc, const char *argv[])
{
//在堆区申请一个4字节的空间大小
int *p1 = (int *)malloc(4);
printf("*p1=%d\n",*p1);
//申请一个int类型的大小
int *p2 = (int *)malloc(sizeof(int));
*p2 = 520; //给堆区空间进行赋值
printf("*p2=%d\n",*p2);
//连续申请5个int类型大小
int *p3 = (int *)malloc(sizeof(int)*5);
//输出默认值
int i = 0;
for(i=0;i<5;i++){
printf("%d\t",p3[i]);
}
putchar(10);
//释放堆区空间
free(p1);
p1 = NULL;
free(p2);
p2 = NULL;
free(p3);
p3 = NULL;
return 0;
} 
练习：要求在堆区申请6个int类型空间存放6名学生的成绩，分别使用函数实现申请空间、输入学生成绩、输出学生成绩、对学生进行升序排序、释放空间
#include
#include
int *memory(int num);
void stuScoIn(int *p,int len);
void stuScoTurn(int *p,int len);
void stuScoOu(int *p,int len);
void myFree(int **p);
int main(int argc, const char *argv[])
{
int num = 6;
int *sco = memory(num); //调用申请空间函数，在堆区申请6个int大小的空间
stuScoIn(sco,num); //调用输入函数完成成绩的录入功能
stuScoTurn(sco,num); //调用排序函数
stuScoOu(sco,num); //调用输出函数
myFree(&sco); //调用内存释放函数
if(NULL == sco){
printf("空间释放成功\n");
}
return 0;
}
//定义从堆区申请空间的函数，num表示要申请空间的个数
int *memory(int num){
int *ptr = (int *)malloc(sizeof(int)*num); //从堆区申请num个int类型的大小空间
if(ptr == NULL){
printf("申请空间失败\n");
return NULL;
}else{
printf("申请空间成功\n");
return ptr;
}
}
//定义输入函数,ptr表示指向堆区空间的地址，num表示堆区空间元素个数
void stuScoIn(int *p,int len){
int i = 0;
if(NULL != p){
for(i=0; i*(p+j+1)){ //升序排列
tmp = *(p+j);
*(p+j) = *(p+j+1);
*(p+j+1) = tmp;
}
}
}
}
void stuScoOu(int *p,int len){
int i = 0;
for(i=0; i 
类型重定义
#include
#include
typedef unsigned short int uint16;//将无符号短整形重命名为uint16
typedef int *Ptr_i;//将int *类型重命名为Ptr_i
typedef char String[10];//将int[10]重命名为String
typedef int (*Ptr_NG)[4];
int main(int argc, const char *argv[])
{
uint16 num = 520; //等价于unsigned short int num = 520
printf("sizeof num = %ld\n",sizeof(num));
printf("num = %d\n",num);
Ptr_i p1=NULL;//此时p1是指针变量，int *p1
printf("sizeof p1 = %ld\n",sizeof(p1));
String s1 = {0}; //定义长度为10的字符数组
strcpy(s1,"hello");
puts(s1);
printf("sizeof s1 = %ld\n",sizeof(s1));
printf("strlen s1 = %ld\n",strlen(s1));
int numG[2][4] = {1,2,3,4,5,6,7,8};
Ptr_NG p2 = numG;
printf("*(*(p2+1))=%d\n",*(*(p2+1))); //观察解引用的逻辑判断是否符合数组指针的逻辑
printf("numG[1][0]=%d\n",numG[1][0]);
return 0;
} 
给类型起多个名
#include
typedef int *Ptr_i,int32;//int32是一个int类型的重命名
//Prt_i是int*类型的重命名
int main(int argc, const char *argv[])
{
int32 num; //nunm是一个int类型的变量
Ptr_i p; //p是一个int×类型的变量
printf("sizeof num = %ld\nsizeof p = %ld\n",sizeof(num),sizeof(p)); //4 8
return 0;
} 
类型重定义与宏定义的区别
#include
#define int32 int //会将int32替换成int
typedef unsigned int uint32;
#define ptr_i int*
typedef int *pptr_i;
int main(int argc, const char *argv[])
{
int32 num = 0;
uint32 key = 0;
ptr_i a,b;
pptr_i m,n;
printf("sizeof a = %ld\n",sizeof(a)); //8,a是int*型
printf("sizeof b = %ld\n",sizeof(b)); //4,b是int型
printf("sizeof m = %ld\n",sizeof(m)); //8,c是int*型
printf("sizeof n = %ld\n",sizeof(n)); //8,d是int*型
return 0;
} 
结构体变量的初始化以及变量访问和结构体指针访问成员
#include
#include
#include
//定义一个英雄结构体类型
struct Hero
{
char name[20];//姓名,构造数据类型
int Hp; //血量
double speed; //基础移速
int kill; //人头数
}h3 = {"盖伦",3500,500,5};
//练习：定义一个商品类型，成员属性：商品名称、产地、单价、重量
#if 1
struct Goods
{
char name[32];
char position[32];
float price;
float weight;
};
#endif
#if 1
struct //无名结构体
{
char name[32];
char position[32];
float price;
float weight;
}g1 = {"三鹿奶粉","China",350,1000};
#endif
int main(int argc, const char *argv[])
{
//使用英雄类型定义一个英雄变量
struct Hero h1 ={"亚索",596,340,0}; //此时定义了一个英雄变量h1
//定义英雄变量，指定某个成员进行赋值
struct Hero h2 = {.Hp=2000,.speed=1000};
//输出英雄变量h1中的所有内容
printf("h1.name = %s\n",h1.name);
printf("h1.Hp = %d\n",h1.Hp);
printf("h1.speed = %lf\n",h1.speed);
printf("h1.kill = %d\n",h1.kill);
struct Hero *ptr = (struct Hero*)malloc(sizeof(struct Hero));
strcpy(ptr->name,"亚瑟");//使用结构体指针进行赋值
ptr->Hp = 3000;
ptr->speed = 350;
ptr->kill = 3;
//输出英雄指针指向堆区空间中的内容
printf("英雄信息：%s\t%d\t%lf\t%d\n",ptr->name,ptr->Hp,ptr->speed,ptr->kill);
free(ptr);
ptr=NULL;
return 0;
}
练习：使用商品结构体定义一个商品变量，不用初始化，使用scanf将每个属性进行输入
#include
struct Goods
{
char name[32];
char position[32];
float price;
float weight;
};
int main(int argc, const char *argv[])
{
struct Goods g1; //定义结构体变量
printf("请输入商品名称：");
scanf("%s",g1.name);//采用‘.’的方式，采用结构体变量的方式进行赋值
printf("请输入商品产地：");
scanf("%s",g1.position);
printf("请输入商品价格：");
scanf("%f",&g1.price);
printf("请输入商品重量：");
scanf("%f",&g1.weight);
putchar(10);
printf("商品名称：%s\n",g1.name);//采用‘.’的方式，采用结构体变量的方式进行输出
printf("商品产地：%s\n",g1.position);
printf("商品价格：%f\n",g1.price);
printf("商品重量：%f\n",g1.weight);
return 0;
} 
思维导图
