C语言从入门到精通保姆级教程（十）
时间：07-25来源：作者：点击数：
static与extern对函数的作用
- 内部函数:只能在本文件中访问的函数
- 外部函数:可以在本文件中以及其他的文件中访问的函数
- 默认情况下所有的函数都是外部函数
- static 作用
- 声明一个内部函数
static int sum(int num1,int num2);
- 定义一个内部函数
static int sum(int num1,int num2)
{
return num1 + num2;
}
- extern作用
- 声明一个外部函数
extern int sum(int num1,int num2);
- 定义一个外部函数
extern int sum(int num1,int num2)
{
return num1 + num2;
}
- 注意点:
- 由于默认情况下所有的函数都是外部函数, 所以extern一般会省略
- 如果只有函数声明添加了static与extern, 而定义中没有添加static与extern, 那么无效
Qt Creator编译过程做了什么?
- 当我们按下运行按钮的时, 其实Qt Creator编译器做了5件事情
- 对源文件进行预处理, 生成预处理文件
- 对预处理文件进行编译, 生成汇编文件
- 对汇编文件进行编译, 生成二进制文件
- 对二进制文件进行链接, 生成可执行文件
- 运行可执行文件
- Qt Creator编译过程验证
- 1.编写代码, 保存源文件:
#include <stdio.h> int main(){ printf("hello lnj\n"); return 0; }
- 2.执行预处理编译
- 执行预处理编译后生成的文件
- 打开预处理编译后生成的文件
- 处理源文件中预处理相关的指令
- 处理源文件中多余注释等
- 3.执行汇编编译
- 执行汇编编译后生成的文件
- 打开汇编编译后生成的文件
- 4.执行二进制编译
- 执行二进制编译后生成的文件
- 打开二进制编译后生成的文件
- 5.执行链接操作
- 将依赖的一些C语言函数库和我们编译好的二进制合并为一个文件
- 执行链接操作后生成的文件
- 6.运行链接后生成的文件
计算机是运算过程分析
- 1.编写一个简单的加法运算
- 2.调试编写好的代码, 查看对应的汇编文件
- 结论:
- 1.通过地址线找到对应地址的存储单元
- 2.通过控制线发送内存读取指令
- 3.通过数据线将内存中的值传输到CPU寄存器中
- 4.在CPU中完成计算操作
- 5.通过地址线找到对应地址的存储单元
- 6.通过控制线发送内存写入指令
- 7.通过数据线将计算结果传输到内存中
预处理指令
预处理指令的概念
- C语言在对源程序进行编译之前，会先对一些特殊的预处理指令作解释(比如之前使用的#include文件包含指令)，产生一个新的源程序(这个过程称为编译预处理),之后再进行通常的编译
- 为了区分预处理指令和一般的C语句，所有预处理指令都以符号“#”开头，并且结尾不用分号
- 预处理指令可以出现在程序的任何位置，它的作用范围是从它出现的位置到文件尾。习惯上我们尽可能将预处理指令写在源程序开头，这种情况下，它的作用范围就是整个源程序文件
- C语言提供了多种预处理功能,如宏定义、文件包含、条件编译等。合理地使用预处理功能编写的程序便于阅读、修改、移植和调试,也有利于模块化程序设计。
宏定义
- 被定义为“宏”的标识符称为“宏名”。在编译预处理时,对程序中所有出现的“宏名”,都用宏定义中的字符串去代换,这称为“宏代换”或“宏展开”。
- 宏定义是由源程序中的宏定义命令完成的。宏代换是由预处理程序自动完成的。在C语言中,“宏”分为有参数和无参数两种。##不带参数的宏定义
- 格式:#define 标识符 字符串
- 其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。
#include <stdio.h>
// 源程序中所有的宏名PI在编译预处理的时候都会被3.14所代替
#define PI 3.14
// 根据圆的半径计radius算周长
float girth(float radius) {
return 2 * PI *radius;
}
int main ()
{
float g = girth(2);
printf("周长为：%f", g);
return 0;
}
- 注意点:
- 宏名一般用大写字母，以便与变量名区别开来，但用小写也没有语法错误
- 2)对程序中用双引号扩起来的字符串内的字符，不进行宏的替换操作
#define R 10
int main ()
{
char *s = "Radio"; // 在第1行定义了一个叫R的宏，但是第4行中"Radio"里面的'R'并不会被替换成10
return 0;
}
- 3)在编译预处理用字符串替换宏名时，不作语法检查，只是简单的字符串替换。只有在编译的时候才对已经展开宏名的源程序进行语法检查
#define I 100
int main ()
{
int i[3] = I;
return 0;
}
-
- 宏名的有效范围是从定义位置到文件结束。如果需要终止宏定义的作用域，可以用#undef命令
#define PI 3.14
int main ()
{
printf("%f", PI);
return 0;
}
#undef PI
void test()
{
printf("%f", PI); // 不能使用
}
-
- 定义一个宏时可以引用已经定义的宏名
#define R 3.0
#define PI 3.14
#define L 2*PI*R
#define S PI*R*R
-
- 可用宏定义表示数据类型,使书写方便
#define String char *
int main(int argc, const char * argv[])
{
String str = "This is a string!";
return 0;
}
带参数的宏定义
- C语言允许宏带有参数。在宏定义中的参数称为形式参数,在宏调用中的参数称为实际参数。对带参数的宏,在调用中,不仅要宏展开,而且要用实参去代换形参
- 格式:#define 宏名(形参表) 字符串
// 第1行中定义了一个带有2个参数的宏average，
#define average(a, b) (a+b)/2
int main ()
{
// 第4行其实会被替换成：int a = (10 + 4)/2;，
int a = average(10, 4);
// 输出结果为：7是不是感觉这个宏有点像函数呢？
printf("平均值：%d", a);
return 0;
}
- 注意点:
- 1)宏名和参数列表之间不能有空格，否则空格后面的所有字符串都作为替换的字符串.
#define average (a, b) (a+b)/2
int main ()
{
int a = average(10, 4);
return 0;
}
注意第1行的宏定义，宏名average跟(a, b)之间是有空格的，于是，第5行就变成了这样：
int a = (a, b) (a+b)/2(10, 4);
这个肯定是编译不通过的
- 2)带参数的宏在展开时，只作简单的字符和参数的替换，不进行任何计算操作。所以在定义宏时，一般用一个小括号括住字符串的参数。
#include <stdio.h>
// 下面定义一个宏D(a)，作用是返回a的2倍数值：
#define D(a) 2*a
// 如果定义宏的时候不用小括号括住参数
int main ()
{
// 将被替换成int b = 2*3+4;，输出结果10，如果定义宏的时候用小括号括住参数，把上面的第3行改成：#define D(a) 2*(a)，注意右边的a是有括号的，第7行将被替换成int b = 2*(3+4);，输出结果14
int b = D(3+4);
printf("%d", b);
return 0;
}
- 3)计算结果最好也用括号括起来
#include <stdio.h>
// 下面定义一个宏P(a)，作用是返回a的平方
#define Pow(a) (a) * (a) // 如果不用小括号括住计算结果
int main(int argc, const char * argv[]) {
// 代码被替换为:int b = (10) * (10) / (2) * (2);
// 简化之后：int b = 10 * (10 / 2) * 2;，最后变量b为:100
int b = Pow(10) / Pow(2);
printf("%d", b);
return 0;
}
#include <stdio.h>
// 计算结果用括号括起来
#define Pow(a) ( (a) * (a) )
int main(int argc, const char * argv[]) {
// 代码被替换为:int b = ( (10) * (10) ) / ( (2) * (2) );
// 简化之后：int b = (10 * 10) / (2 *2);，最后输出结果：25
int b = Pow(10) / Pow(2);
printf("%d", b);
return 0;
}
条件编译
- 在很多情况下，我们希望程序的其中一部分代码只有在满足一定条件时才进行编译，否则不参与编译(只有参与编译的代码最终才能被执行)，这就是条件编译。
- 为什么要使用条件编译
- 1)按不同的条件去编译不同的程序部分,因而产生不同的目标代码文件。有利于程序的移植和调试。
- 2)条件编译当然也可以用条件语句来实现。但是用条件语句将会对整个源程序进行编译,生成 的目标代码程序很长,而采用条件编译,则根据条件只编译其中的程序段1或程序段2,生成的目 标程序较短。##if-#else 条件编译指令
- 第一种格式:
- 它的功能是,如常量表达式的值为真(非0),则将code1 编译到程序中,否则对code2编译到程序中。
- 注意:
- 是将代码编译进可执行程序, 而不是执行代码
- 条件编译后面的条件表达式中不能识别变量,它里面只能识别常量和宏定义
#if 常量表达式
..code1...
#else
..code2...
#endif
#define SCORE 67
#if SCORE > 90
printf("优秀\n");
#else
printf("不及格\n");
#endif
- 第二种格式:
#if 条件1
...code1...
#elif 条件2
...code2...
#else
...code3...
#endif
#define SCORE 67
#if SCORE > 90
printf("优秀\n");
#elif SCORE > 60
printf("良好\n");
#else
printf("不及格\n");
#endif
typedef关键字
- C语言不仅供了丰富的数据类型,而且还允许由用户自己定义类型说明符,也就是说允许由用户为数据类型取“别名”。
- 格式:typedef 原类型名 新类型名;
- 其中原类型名中含有定义部分,新类型名一般用大写表示,以便于区别。
- 有时也可用宏定义来代替typedef的功能,但是宏定义是由预处理完成的,而typedef则是在编译 时完成的,后者更为灵活方便。##typedef使用
- 基本数据类型
typedef int INTEGER
INTEGER a; // 等价于 int a;
- 也可以在别名的基础上再起一个别名
typedef int Integer;
typedef Integer MyInteger;
- 用typedef定义数组、指针、结构等类型将带来很大的方便,不仅使程序书写简单而且使意义更为 明确,因而增强了可读性。
- 数组类型
typedef char NAME[20]; // 表示NAME是字符数组类型,数组长度为20。然后可用NAME 说明变量,
NAME a; // 等价于 char a[20];
- 结构体类型
- 第一种形式:
struct Person{
int age;
char *name;
};
typedef struct Person PersonType;
+ 第二种形式:
typedef struct Person{
int age;
char *name;
} PersonType;
+ 第三种形式:
typedef struct {
int age;
char *name;
} PersonType;
- 枚举
- 第一种形式:
enum Sex{
SexMan,
SexWoman,
SexOther
};
typedef enum Sex SexType;
+ 第二种形式:
typedef enum Sex{
SexMan,
SexWoman,
SexOther
} SexType;
+ 第三种形式:
typedef enum{
SexMan,
SexWoman,
SexOther
} SexType;
- 指针
- typedef与指向结构体的指针
// 定义一个结构体并起别名
typedef struct {
float x;
float y;
} Point;
// 起别名
typedef Point *PP;
- typedef与指向函数的指针
// 定义一个sum函数，计算a跟b的和
int sum(int a, int b) {
int c = a + b;
printf("%d + %d = %d", a, b, c);
return c;
}
typedef int (*MySum)(int, int);
// 定义一个指向sum函数的指针变量p
MySum p = sum;
宏定义与函数以及typedef区别
- 与函数的区别
- 从整个使用过程可以发现，带参数的宏定义，在源程序中出现的形式与函数很像。但是两者是有本质区别的：
- 1> 宏定义不涉及存储空间的分配、参数类型匹配、参数传递、返回值问题
- 2> 函数调用在程序运行时执行，而宏替换只在编译预处理阶段进行。所以带参数的宏比函数具有更高的执行效率
- typedef和#define的区别
- 用宏定义表示数据类型和用typedef定义数据说明符的区别。
- 宏定义只是简单的字符串替换,是在预处理完成的
- typedef是在编译时处理的,它不是作简单的代换,而是对类型说明符重新命名。被命名的标识符具有类型定义说明的功能
typedef char *String;
int main(int argc, const char * argv[])
{
String str = "This is a string!";
return 0;
}
#define String char *
int main(int argc, const char * argv[])
{
String str = "This is a string!";
return 0;
}
typedef char *String1; // 给char *起了个别名String1
#define String2 char * // 定义了宏String2
int main(int argc, const char * argv[]) {
/*
只有str1、str2、str3才是指向char类型的指针变量
由于String1就是char *，所以上面的两行代码等于:
char *str1;
char *str2;
*/
String1 str1, str2;
/*
宏定义只是简单替换, 所以相当于
char *str3, str4;
*号只对最近的一个有效, 所以相当于
char *str3;
char str4;
*/
String2 str3, str4;
return 0;
}
const关键字
- const是一个类型修饰符
- 使用const修饰变量则可以让变量的值不能改变 ##const有什么主要的作用?
- (1)可以定义const常量,具有不可变性
const int Max=100;
int Array[Max];
- (2)便于进行类型检查,使编译器对处理内容有更多了解,消除了一些隐患。
void f(const int i) { .........}
- 编译器就会知道i是一个常量,不允许修改;
- (3)可以避免意义模糊的数字出现,同样可以很方便地进行参数的调整和修改。同宏定义一样,可以做到不变则已,一变都变!如(1)中,如果想修改Max的内容,只需要:const int Max=you want;即可!
- (4)可以保护被修饰的东西,防止意外的修改,增强程序的健壮性。还是上面的例子,如果在 函数体内修改了i,编译器就会报错;
void f(const int i) { i=10;//error! }
- (5) 可以节省空间,避免不必要的内存分配。
#define PI 3.14159 //常量宏
const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ...... double i=Pi; //此时为Pi分配内存,以后不再分配!
double I=PI; //编译期间进行宏替换,分配内存
double j=Pi; //没有内存分配
double J=PI; //再进行宏替换,又一次分配内存! const定义常量从汇编的角度来看,只是给出了对应的内存地址,而不是象#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝,而#define定义的常量在内存 中有若干个拷贝。
- (6) 高了效率。编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表 中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高。
如何使用const?
- (1)修饰一般常量一般常量是指简单类型的常量。这种常量在定义时,修饰符const可以用在类型说明符前,也可以用在类型说明符后
int const x=2; 或 const int x=2;
- (当然,我们可以偷梁换柱进行更新: 通过强制类型转换,将地址赋给变量,再作修改即可以改变const常量值。)
// const对于基本数据类型, 无论写在左边还是右边, 变量中的值不能改变
const int a = 5;
// a = 666; // 直接修改会报错
// 偷梁换柱, 利用指针指向变量
int *p;
p = &a;
// 利用指针间接修改变量中的值
*p = 10;
printf("%d\n", a);
printf("%d\n", *p);
- (2)修饰常数组(值不能够再改变了)定义或说明一个常数组可采用如下格式:
int const a[5]={1, 2, 3, 4, 5};
const int a[5]={1, 2, 3, 4, 5};
const int a[5]={1, 2, 3, 4, 5};
a[1] = 55; // 错误
- (3)修饰函数的常参数const修饰符也可以修饰函数的传递参数,格式如下:void Fun(const int Var); 告诉编译器Var在函数体中的无法改变,从而防止了使用者的一些无 意的或错误的修改。
- (4)修饰函数的返回值: const修饰符也可以修饰函数的返回值,是返回值不可被改变,格式如 下:
const int Fun1();
const MyClass Fun2();
- (5)修饰常指针
- const int *A; //const修饰指针,A可变,A指向的值不能被修改
- int const *A; //const修饰指向的对象,A可变,A指向的对象不可变
- int *const A; //const修饰指针A, A不可变,A指向的对象可变
- const int *const A;//指针A和A指向的对象都不可变
- 技巧
先看“*”的位置
如果const 在 *的左侧 表示值不能修改,但是指向可以改。
如果const 在 *的右侧 表示指向不能改,但是值可以改
如果在“*”的两侧都有const 标识指向和值都不能改。
内存管理
进程空间
- 程序，是经源码编译后的可执行文件，可执行文件可以多次被执行，比如我们可以多次打开 office。
- 而进程，是程序加载到内存后开始执行，至执行结束，这样一段时间概念，多次打开的wps,每打开一次都是一个进程，当我们每关闭一个 office，则表示该进程结束。
- 程序是静态概念，而进程动态/时间概念。###进程空间图示 有了进程和程序的概念以后，我们再来看一下，程序被加载到内存以后内存空间布局是什么样的
方便获取更多学习、工作、生活信息请关注本站微信公众号
上一篇:C语言从入门到精通保姆级教程（九）
下一篇:C语言从入门到精通保姆级教程（十一）
湘公网安备 43102202000103号