初学c课程笔记整理9-->>重点概念集（全记终）

是什么？有什么用？用在什么地方？(理解)

养成良好的编程习惯;

培养编程思想；

写代码之前应该先分析需求，分析完需求再开始写代码；（写注释）

 

1.变量作用域基本概念

 

         变量作用域：变量的可用范围

 

         按照作用域的不同，变量可以分为：局部变量和全局变量

 

 1.1 局部变量：

 

       定义在函数内部的变量以及函数的形参称为局部变量

 

       作用域：从定义哪一行开始直到与其所在的代码块结束  

      

       存储位置：局部变量存储在栈中, 当作用域结束系统会自动释放栈中的局部变量

 

       生命周期:从程序运行到定义哪一行开始分配存储空间到程序离开该变量所在的作用域

 

特点：

1、相同作用域内不可以定义同名变量

2、不同作用范围可以定义同名变量，内部作用域的变量会覆盖外部作用域的变量

注意:

    局部变量没有固定的初始化值, 如果没有对局部变量进行初始化, 那么局部变量中是一些随机的值, 所以在开发中千万不要使用未初始化的局部变量

 

1.2 全局变量：

 

     定义在函数外边的变量称为全局变量

 

     作用域范围：从定义哪行开始直到文件结尾

 

     生命周期:程序一启动就会分配存储空间,直到程序结束

 

     存储位置：  全局变量存储在静态区中, 他会随着程序的启动而创建, 随着程序的结束而结束

 

特点:

    1、全局变量和局部变量可以同名，多个同名的全局变量指向同一块存储空

  2、如果存在和全局变量同名的局部变量, 那么局部变量会覆盖全局变量

注意:

    全局变量如果没有进行初始化, 那么系统默认会将全局变量初始化为0

 

2.static和extern关键字

 

为了提高数据的安全性, 不让别人在其它文件中修改我们的全局变量, C语言提供了另外一个用于修改全局变量的关键字, static
 只要用static修改的全局变量就是内部全局变量, 只能在当前文件中使用
 这样就可以提高我们全局变量的安全性
 
 如果多个文件中存在同名的内部全局变量, 相互不会影响

 如果既有外部全局变量也有内部全局变量, 那么会优先访问内部全局变量

 extern:
    用于声明一个外部全局变量
    声明只需要在使用变量之前声明就可以了
 static:
    用于定义一个内部全局变量
 声明和定义的区别:
    声明不会开辟存储空间

    定义会开辟存储空间

 

 static对局部变量的作用

 

  当使用static来修饰局部变量, 那么会延长局部变量的生命周期, 并且会更改局部变量存储的位置 , 将局部变量从栈转移到静态区中。

 

  只要使用static修改局部变量之后, 当执行到定义局部变量的代码就会分配存储空间, 但是只有程序结束才会释放该存储空间

static对局部变量的作用

 

     应用场景:

     当某个方法的调用频率非常高, 而该方法中更有些变量的值是固定不变的
     那么这个时候就可以使用static来修饰该变量, 让该变量只开辟一次存储空间

     这样可以提高程序的效率和性能

 

 extern对局部变量的作用

 

extern用在函数内部

     不是定义局部变量,它用在函数内部是声明一个全局变量

 

 全局变量分类

     内部变量:只能在本文件中访问的变量

     外部变量:可以在其他文件中访问的变量,默认所有全局变量都是外部变量

 

static对全局变量的作用

 

     声明一个内部变量

    static int a;

     定义一个内部变量

    static int a = 10;

 

由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用,因此可以 避免在其它源文件中引起错误。

 

extern对全局变量作用

 

     完整声明一个外部变量

        extern int a;

     完整定义一个外部变量

        extern int a = 10;

 

如果声明的时候没有写extern那系统会自动定义这个变量,并将其初始化为0

如果声明的时候写extern了，那系统不会自动定义这个变量。

 

extern和static对函数的作用

 

   声明内部函数一般用于内部函数定义在后面, 而想在定义之前使用内部函数   

只要在函数的返回值前面加上一个extern就可以让函数变为一个外部函数, 由于默认就是外部函数, 所以在开发中一般情况extern没人写

 如果extern写在函数的实现中, 代表定义一个外部函数

 如果extern写在函数的声明中, 代表声明一个外部函数

 

 只要在函数的返回值前面加上static就可以让函数变为内部函数, 其它文件就不能访问了

 如果static写在函数的实现中, 代表定义一个内部函数

 如果static写在函数的声明中, 代表声明一个内部函数

 

3.预处理指令

 

什么是预处理指令:

    在我们的文件翻译成0和1之前做的操作我们称之为预处理指令
    一般情况预处理指令都是以#号开头的

 

 宏定义

 条件编译

 文件包含

 

3.1 宏定义

 

宏定义的格式

    1.不带参数的宏定义
    2.带参数的宏定义
 
 #define 宏名 值
 
 宏定义的作用:   
    会在程序翻译成0和1之前, 将所有宏名替换为 宏的值
 

 宏定义在什么时候替换

 源代码 --> 预处理 -->汇编 -->二进制 -->可执行程序
 
 规范:
 一般情况宏名都大写, 多个单词之间用_隔开, 并且每个单词全部大写
 有得公司又要求宏名以k开头, 多个单词之间用驼峰命名
 

注意:

    宏定义后面不要写分号

       宏名一般用大写字母，以便与变量名区别开来，但用小写也没有语法错误

       对程序中用双引号扩起来的字符串内的字符，不进行宏的替换操作

 
 宏定义也有作用域
    从定义的那一行开始, 一直到文件末尾
    虽然默认情况下宏定义的作用域是从定义的那一行开始, 一直到文件末尾. 但是我们也可以通过对应的关键字提前结束宏定义的作用域

 

宏定义的使用场景:

    http://192.168.13.11/login
    http://192.168.13.11/accesstoken

    http://192.168.13.11/file,,,

#define BASE_URL " http://192.168.13.11/"

   
    获取屏幕的宽度
    获取手机系统版本号
    做一个单利
    判断系统版本

    ...

 

带参数的宏定义

 

 #define 代表要定义一个宏

 宏的名称

 参数, 注意点, 不需要写数据类型

 用于替换的内容

 
 宏定义并不会做任何运算, 无论是有参数还是没有参数都仅仅是在翻译成0和1之前做一个简单的"替换"
 
 带参数的宏定义注意点
 1.一般情况下建议写带参数的宏的时候, 给每个参数加上一个()

 2.一般情况下建议写带参数的宏的时候, 给结果也加上一个()

 

什么时候用带参数的宏定义什么时候用函数

     如果函数内部的功能比较简单, 仅仅是做一些简单的运算那么可以使用宏定义, 使用宏定义效率更好, 运算速度更快

     如果函数内部的功能比较复杂, 不仅仅是一些简单的运算, 那么建议使用函数

 

3.2 条件编译

 

条件编译基本概念

 

在很多情况下，我们希望程序的其中一部分代码只有在满足一定条件时才进行编译，否则不参与编译(只有参与编译的代码最终才能被执行)，这就是条件编译

    

条件编译和if非常非常像

    if选择结构会对给定条件进行判断, 如果条件满足就执行if后面大括号中的内容

    条件编译也一样, 会对给定的条件进行判断, 如果条件满足就编译条件后面的内容

 

条件编译和选则结构if的共同点

 都可以对给定的条件进行判断, 添加满足或者不满足都可以执行特定的代码

 

 条件编译和选则结构if的共区别

 1.生命周期不同
    if 运行时
    #if 编译之前
 2.#if需要一个明确的结束符号 #endif
    为什么需要一个明确的结束符号?
    如果省略掉#endif, 那么系统就不知道条件编译的范围, 那么会将满足条件之后的第二个条件之后的所有内容都清除
 3.if会将所有的代码都编译到二进制中

  #if只会将满足条件的部分一直到下一个条件的部分 编译到二进制中

 

 
 条件编译的优点
 1.缩小应用程序的大小
 
 应用场景:
 用于调试和发布阶段进行测试
 调试阶段: 程序写代码的阶段

 发布阶段: 上传到AppStore的阶段

 

    预处理指令什么时候执行? 编译之前

   变量什么时候定义? 执行了才会定义

    注意点: 条件编译不能用来判断变量, 因为不在同一个生命周期

           一般情况下, 条件编译是和宏定义结合在一起使用的

 

#if-#else 条件编译指令格式

 

- 第一种格式:

```

#if 常量表达式

    ..code1...

#else

    ..code2...

#endif

```

 

```

#define SCORE 67

#if SCORE > 90

    printf("优秀\n");

#else

    printf("不及格\n");

#endif

```

     它的功能是,如常量表达式的值为真(非0),则对code1 进行编译,否则对code2进行编译。因此可以使程序在不同条件下,完成不同的功能。

 

    注意:条件编译后面的条件表达式中不能识别变量,它里面只能识别常量和宏定义

 

- 第二种格式:

 

```

#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

```

     1>如果条件1成立，那么编译器就会把#if 与 #elif之间的code1代码编译进去（注意：是编译进去，不是执行，很平时用的if-else是不一样的）

     2> 如果条件1不成立、条件2成立，那么编译器就会把#elif 与 #else之间的code2代码编译进去

     3> 如果条件1、2都不成立，那么编译器就会把#else 与 #endif之间的code3编译进去

     4> 注意，条件编译结束后，要在最后面加一个#endif，不然后果很严重(自己思考一下后果)

     5> #if 和 #elif后面的条件一般是判断宏定义而不是判断变量，因为条件编译是在编译之前做的判断，宏定义也是编译之前定义的，而变量是在运行时才产生的、才有使用的意义

 

---

 

#ifdef 条件编译指令

 格式:

 

```

#ifdef 标识符

    程序段1

#else

    程序段2

#endif

```

     它的功能是,如果标识符已被#define命令定义过则对程序段1进行编译;否则对程序段2进行编译。如果没有程序段2(它为空),本格式中的#else可以没有,即可以写为:

 

```

#ifdef 标识符 程序段

#endif

```

 

 

4.ifndef 条件编译指令

- 格式:

 

```

#ifndef 标识符 程序段1

#else 程序段2

#endif

```

     与第二种形式的区别是将“ifdef”改为“ifndef”。它的功能是,如果标识符未被#define命令 定义过则对程序段1进行编译,否则对程序段2进行编译。这与第二种形式的功能正相反。

 

 

使用条件编译指令调试bug

 应用:可变参数宏,更方便地打印调试信息

 

```

#define DEBUG1 1

#if DEBUG1 == 0 //format是格式控制,##表示可以没有参数,__VA_ARGS__表示变量 #define Log(format,...) printf(format,## __VA_ARGS__)

#else

#define Log(format,...)

#endif

 

void test(){

    Log("xxxxx");

}

int main(int argc, const char * argv[]) {

    Log("%d\n",10);

    return 0;

}

```

 这里,‘...’指可变参数。这类宏在被调用时,##表示成零个或多个参数,包括里面的逗号,一直到到右括弧结束为止。当被调用时,在宏体(macro body)中,那些符号序列集合将代替里面 的__VA_ARGS__标识符。

 

3.3 文件包含

 

 函数可以重复声明, 但不能重复定义

 

 重复导入会降低编译效率

 

 #include <>
 <>会先去编译器环境下查找, 找不到再去系统的环境下查找

 #include ""
 ""会先在当前文件查找, 找不到再去编译器环境下查找, 找不到再去系统的环境下查找
 
 作用:
 将""或者<>中的内容完全拷贝过来
 
 注意:
 如果正确的编写.h文件
 如果防止循环拷贝  A拷贝B, B拷贝A

 间接拷贝问题  A拷贝B, B拷贝C, C拷贝D

 

3.4 Typedef

 

什么是typedef, 它有什么作用

 typedef可以给一个已知的数据类型起别名 (外号)
 
 利用typedef给数据类型起别名的格式:
 
 typedef 原有的数据类型 别名(外号);
 
 注意:
 1. typedef不仅能给系统原有的数据类型起别名, 也可以给一个自定义的数据类型起别名

 2. 利用typedef给数据类型起别名, 并不会生成一个新的数据类型, 仅仅是给原有的类型起了一个别名而已

 */

int sum(int v1, int v2)
{
    return v1 + v2;
}

int minus(int v1, int v2)
{
    return v1 - v2;
}

// 注意: 如果是给指向函数的指针起别名, 那么指向函数的指针的指针名称就是它的别名
// functionPotinter == int(*functionPotinter)(int , int)
typedef int(*functionPotinter)(int , int);
int main(int argc, const char * argv[]) {
  
    // 9如何定义变量 :   数据类型 变量名称;
//    int (*sumP)(int , int ) = sum;
    functionPotinter sumP = sum;
    printf("sum = %i\n", sumP(10 , 20));
   
//    int (*minusP)(int, int) = minus;
    functionPotinter minusP = minus;
    printf("minus = %i\n", minusP(20, 10));
    return 0;
}

// ----------------------------给指针起别名----------------------------
// String == char *
typedef char * String;
void test4()
{
    //    char *name = "lnj";
    // 注意: 如果给指针起别名之后, 那么以后利用别名定义变量就不用再加*了
    String name = "lnj";
    printf("name = %s\n", name);
   
   
}

// ----------------------------给枚举类型起别名----------------------------

// 1.先定义枚举类型, 再给枚举类型起别名
/*
 enum Gender
 {
 kGenderMale,
 kGenderFemale
 };
 typedef enum Gender SEX;
 */

// 2.定义枚举类型的同时给枚举类型起别名
/*
 typedef enum Gender
 {
 kGenderMale,
 kGenderFemale
 } SEX;
 */

// 3.定义枚举类型的同时给枚举类型起别名, 并且省略枚举原有类型名称
typedef enum
{
    kGenderMale,
    kGenderFemale
} SEX;

void test3()
{
   
    // 给枚举起别名
    //    enum Gender sex;
    SEX sex;
    sex = kGenderMale;
    /*
     定义枚举变量有3种方式
     1.先定义枚举类型, 再定义枚举变量
     2.定义枚举类型的同时定义枚举变量
     3.定义枚举类型的同时定义枚举变量, 并且省略枚举类型名称
     */
    /*
     enum Gender2
     {
     kGenderMale2,
     kGenderFemale2
     } sex2;
     sex2 = kGenderFemale2;
    
     enum
     {
     kGenderMale3,
     kGenderFemale3
     } sex3;
     sex3 = kGenderFemale3;
     */
   
}
// ----------------------------给结构体类型起别名----------------------------


// 1.先定义结构体类型, 再给类型起别名
/*
 struct Person
 {
 int age;
 double height;
 char *name;
 };
 // SPerson == struct Person
 typedef struct Person SPerson;
 */

// 2.定义结构体类型的同时, 给结构体类型起别名
/*
 typedef struct Person
 {
 int age;
 double height;
 char *name;
 } SPerson;
 */

// 3.定义结构体类型的同时, 给结构体类型起别名, 并且省略掉原有类型的名称

 typedef struct
 {
 int age;
 double height;
 char *name;
 } SPerson;
void test2()
{
    /*     // 给构造类型起别名     struct Person     {     int age;     double height;     char *name;     };     *///    struct Person sp0;    SPerson sp;    SPerson sp1;    SPerson sp2;    SPerson sp3;    SPerson sp4;    /*     结构体变量的定义方式     1.先定义类型再定义变量     2.定义类型的同时定义变量     3.定义类型的同时定义变量, 并且省略类型名称     */}// ----------------------------给基本数据类型起别名----------------------------// Integer == inttypedef int Integer;typedef Integer myInt;// int float doulbe charvoid test1(){    int num = 10;    printf("num = %i\n", num);       Integer age = 30;    printf("age = %i\n", age);       myInt score = 99;    printf("score = %i\n", score);

}

 

typedef和宏定义的区别

typedef int myInt;
#define Integer int

typedef char * String;
#define MY_STRING char *

// 一般情况下如果要给数据类型起一个名称建议用typedef, 不要用define

 

 4.const关键字

 

什么是const?

 const是一个类型修饰符

     使用const修饰变量则可以让变量的值不能改变

     常类型是指使用类型修饰符const说明的类型,常类型的变量或对象的值是不能被更新的。

 

const的作用

 (1)可以定义const常量,具有不可变性。 

 

(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 int a = 5;

    int *p;

    p = (int *)&a;

    *p = 10;

    printf("%d\n", a);

    printf("%d\n", *p);

输出结果: 5, 10

```

 

(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 标识指向和值都不能改

    （const对基本数据类型的作用, 可以让基本数据类型的变量变为常量

     const有两种写法, 1.写在数据类型的左边, 2.写在数据类型的右边

     如果const写在指针类型的左边, 那么意味着指向的内存空间中的值不能改变, 但是指针的指向可以改变
     如果const写在指针的数据类型和*号之间, 那么意味着指向的内存空间中的值不能改变, 但是指针的指向可以改变
     如果const写在指针的右边(数据类型 * const), 那么意味着指针的指向不可以改变, 但是指针指向的存储空间中的值可以改变
    
     规律:
     如果const写在指针变量名的旁边, 那么指针的指向不能变, 而指向的内存空间的值可以变

     如果const写在数据类型的左边或者右边, 那么指针的指向可以改变, 但是指向的内存空间的值不能改变）