模块之间的数据传递

动态内存分配
copy函数的功能是复制字符串，是否有问题？
char *copy(char *str) { int i; int carbon[MAX_LEN]; for(i=0; str[i] != '\0'; i++) { carbon[i] = str[i]; } carbon[i] = '\0'; return carbon; } int main() { int *p = "abcdef"; int *q; q = copy(p); printf("%s\n", q); return 0; }
动态内存分配
malloc函数申请的空间，在整个程序运行过程 中都是有效的 因此当动态申请的空间不再使用时，应使用 free函数手动释放，否则会造成内存泄漏

int *p, a; p = (int *)malloc(10000); p = &a;
动态内存分配
malloc函数申请的空间，在整个程序运行过程 中都是有效的 因此当动态申请的空间不再使用时，应使用 free函数手动释放，否则会造成内存泄漏
2.5
s.b
a
s.c
传递结构体

结构体变量地址作为参数
void fun(STRUCT *p) { …… } &s int main() { STRUCT s = {1, 2.5, ‘a’}; fun(&s); } s 1
s.a
p &s
typedef struct { int a; float b; char c; } STRUCT;
fun(a) fun(&a[0])
返回值

返回变量值
int fun() { int b = 2; return b; } int main() { int a; a = fun(); } b 2
2
2 a
返回值

返回地址
动态分配的空间
静态局部变量

返回自动类或寄存器类局部变量的地址是没有 意义的，因为它们在函数执行结束就销毁了
a
1
&a
&a p
&a p
传递结构体

结构体变量作为参数
void fun(STRUCT t) { …… } int main() { STRUCT s = {1, 2.5, ‘a’}; fun(s); } t.a 1 t.b 2.5
t
t.c a
1, 2.5, a s 1
s.a
typedef struct { int a; float b; char c; } STRUCT;
a
int main() { STRUCT a[3] = { {1, 2.5, a}, {2, 3.5, b}, {3, 4.5, c} }; fun(a); }
a
1
2.5
a b
c
a+1
a+2
2
33.54.5array+2
传递结构体
返回结构体数组，实际上就是返回结构体数组 的首元素地址 但如果返回的结构体数组是自动类或寄存器类 ，也是没有意义的，因为在函数执行结束时， 它们已经被销毁了
动态内存分配
申请能够存放5个整型数据的空间： int *p; p = (int *)malloc(sizeof(int) * 5); p[0] = 1; *(p+1) = 2;
动态内存分配
copy函数的功能是复制字符串，是否有问题？
char *copy(char *str) { int i; int carbon[MAX_LEN]; for(i=0; str[i] != '\0'; i++) { carbon[i] = str[i]; } carbon[i] = '\0'; return carbon; } int main() { int *p = "abcdef"; int *q; q = copy(p); printf("%s\n", q); return 0; }
传递结构体

返回自动类或寄存器类结构体变量的地址同样 是没有意义的，因为在函数执行结束时，它们 已经被销毁了
传递结构体

结构体数组作为参数
array typedef struct { int a; float b; char c; } STRUCT;
void fun(STRUCT *array) { …… }

全局变量

不同的函数之间可以通过全局变量传递数据
int a[10]; void fun_1() { int i; for(i=0; i<10; i++) { scanf(“%d”, &a[i]); } } void fun_2() { int i, s; s = 0; for(i=0; i<10; i++) { s += a[i]; } }

参数传递

传值
a void fun(int a, float b) { …… } 1 b 1
int main() { int a = 1; float b = 2.5; fun(a, b) }
1
2.5
1 a
2.5
b
参数传递

传址
void fun(int *p, float *q) { …… } p &a q &b
全局变量
不同的函数之间可以通过全局变量传递数据 这种方法的缺点是会降低模块本身的独立性， 提高模块之间的耦合性

参数传递
函数的参数传递有两类：传值和传址 实际上，传址传的是地址值 函数定义时的参数称为形参，函数调用时的参 数称为实参 实参有实际值，形参在被调用时接收实参的值 参数的传递时单向的：实参 形参
动态内存分配

在C语言中，有两种申请内存空间的方法：
定义变量
动态内存分配

动态申请内存的函数为：
void *malloc(unsigned int len);
该函数向编译器申请长度为len个字节的空间， 并将空间的首地址作为返回值返回 申请的空间默认为void型，但可以通过强制类 型转换，转换为其它类型
动态内存分配
程序的存储区分为三部分：代码区、静态存储 区、动态存储区（分为栈区和堆区） 代码区存放程序代码 静态存储区存放常量、静态变量、全局变量 栈区由编译器管理，存放局部变量、函数参数、 返回值等 堆区由程序员自主申请和释放 申请堆空间使用malloc函数，释放堆空间使用 free函数
int main() { int a = 1; float b = 2.5; fun(&a, &b) }
&a
&b
1
a
2.5
b
参数传递

传递一维数组
void fun(int *array) { …… } int main() { int a[5]; fun(a) } a
a
array
a
参数传递

形参的语法形式

int *p, a; p = (int *)malloc(10000); free(p); p = &a;
a int main() { int a[2][3]; fun(a) }
a a+1 array+1
参数传递

形参的语法形式
void
fun(int array[2][3]) void fun(int array[][3]) void fun(int (*array)[3])

实参的语法形式（已有定义：int a[2][3]）
2.5
s.b
a
s.c
传递结构体

结构体变量作为返回值
void fun() { STRUCT t = {5, 8.5,‘x’}; return t; } int main() { STRUCT s; s = fun(); } t.a 5 t.b 8.5 t 5, 8.5, x s 1 s.a 2.5 s.b a s.c t.c x typedef struct { int a; float b; char c; } STRUCT;
模块之间的数据传递
主 讲：唐郑熠 学 院：信息科学与工程学院
内容提要




参数传递 函数返回值 传递结构体 动态内存分配
变量的作用域
C语言中的存储类型分为：auto、register、 static、extern， 在函数内部定义的变量称为局部变量，在函数 外部定的变量称为全局变量 全局变量具有全局作用域，只需在一个源文件 中定义，就可以作用于所有的源文件（需用 extern声明） 静态全局变量只能在定义的源文件内部使用， 不能被其它源文件使用

动态内存分配

在C语言中，有两种申请内存空间的方法：
定义变量
动态内存分配

动态申请内存的函数为：
void *malloc(unsigned int len);
该函数向编译器申请长度为len个字节的空间， 并将空间的首地址作为返回值返回 申请的空间默认为void型，但可以通过强制类 型转换，转换为其它类型
返回值
int *fun() { int a = 1; return &a; }
int main() { int *p; p = fun(); …… }
a 1
int *fun() { static int a = 1; return &a; } int main() { int *p; p = fun(); …… } &a