您当前的位置:首页 > 计算机 > 编程开发 > C语言

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;
}
  • 注意点:
    1. 宏名一般用大写字母,以便与变量名区别开来,但用小写也没有语法错误
  • 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;
 }
    1. 宏名的有效范围是从定义位置到文件结束。如果需要终止宏定义的作用域,可以用#undef命令
#define PI 3.14
int main ()
 {
    printf("%f", PI);
    return 0;
}
#undef PI
void test()
{
    printf("%f", PI); // 不能使用
}
    1. 定义一个宏时可以引用已经定义的宏名
#define R  3.0
#define PI 3.14
#define L  2*PI*R
#define S  PI*R*R
    1. 可用宏定义表示数据类型,使书写方便
#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,则表示该进程结束。
  • 程序是静态概念,而进程动态/时间概念。###进程空间图示 有了进程和程序的概念以后,我们再来看一下,程序被加载到内存以后内存空间布局是什么样的
    图片
方便获取更多学习、工作、生活信息请关注本站微信公众号城东书院 微信服务号城东书院 微信订阅号
推荐内容
相关内容
栏目更新
栏目热门
本栏推荐