C语言 ---- 第一章 初识C语言

第一节 算法分析

• 计算机语言是用来编写程序交给计算机执行的，利用计算机超高的运行速度达到目的
• 算法：完成一项任务所需要的步骤
• 1-100累加运算的算法：
  • 1. 在内存里声明两个存储单元，A(加数)存放数值0，B(运算结果)存放数值1
    2. 将2个存储单元中的数值相加，并将结果放入存储单元A
    3. 将存储单元B的数值+1
    4. 如果存储单元B的数值≤100，则跳转到第二步去执行；否则停止执行

第二节 类型指定符、基本类型、标识符、关键字、变量、声明

• 声明变量的语法：类型指定符 标识符;
• 声明变量以后，处理器会在内存中占用一个存储单元(变量)
  • 存储单元中的数值不是固定的，是可以更改的量，称为变量(标识符A所指示的变量)
• 程序在内存中声明变量以后，要确定三个问题：
  • 1. 指令所声明的存储单元有多大？
    2. 这个存储单元是用于存储那种类型的数据(或者说应该按照哪种规则来访问这个存储单元)？
       • int：类型指定符
       • int A; == signed int A; == singed A; --> 用于存储“有符号整数”
       • int : C语言中的基本类型之一
       • C语言规定：int类型的存储空间，“最小”是两个字节，它的大小会根据不同的编译器而有所不同
    3. 如何访问？
    • A : 标识符
    • 标识符的命名规则：
      • 1. 可以由下划线、26个大写英文字母、26个小写英文字母、0-9的数字所组成
        2. 不能以数字开头
        3. 不能和“关键字”同名
        4. 标识符长度建议控制在31个字符以内
    • int : 关键字
      • 1. 可以理解为：C语言的专属标识符
        2. 编译器赋予了它固定的意义和用途
        3. 错误的例子： int int
    • C语言区分大小写：
      • 1. A和a是完全不同的两个标识符
        2. 错误的例子：iNt A;

第三节 基本类型之标准整数类型

• 基本类型：
  • 整数类型
    • 无符号整数类型
      • 标准无符号整数类型
      • 扩展无符号整数类型
    • 有符号整数类型
      • 标准有符号整数类型
      • 扩展有符号整数类型
        • 标准无符号整数类型和标准有符号整数类型组成标准整数类型
          • 标准有符号整数类型(存储规则：补码表示法；解析规则：补码表示法)：
            • signed char : 最少占用1个字节
            • short int ：最少占用2个字节
            • int : 最少占用2个字节
            • long int : 最少占用4个字节
            • long long int : 最少占用8个字节
          • 标准无符号整数类型(存储规则：补码表示法、无符号表示法；解析规则：无符号表示法)：
            • unsigned char : 最少占用1个字节
            • unsigned short int : 最少占用2个字节
            • unsigned int : 最少占用2个字节
            • unsigned long int : 最少占用4个字节
            • unsigned long long int : 最少占用8个字节
            • _Bool(只能用来存储0和1) ：最少占用1个字节
          • 这些类型决定了变量的2个性质：
            • 存储单元的大小
            • 存储单元的访问规则(存储规则<写>、解析规则<读>)
          • 3个问题：
            • 1. 这些类型的实际存储范围是多少？
              2. char、signed char、unsigned char之间的区别与联系
              3. int 和short int的最小存储范围为什么都是2个字节，二者的区别在哪里？
        • 扩展无符号整数类型和扩展由符号整数类型组成扩展整数类型
  • 浮点类型
  • char类型

第四节 类型的多种写法之类型指定符

• 在声明整数类型的变量时，除了signed char、unsigned char、 bool类型以外，其余8种类型均有不同的写法
  • short int ----> short、 signed short、 signed short int
  • int ----> signed、signed int
  • long int ----> long、signed long、signed long int
  • long long int ----> long long、 signed long long、signed long long int
  • unsigned short int ----> unsigned short
  • unsigned int ----> unsigned
  • unsigned long int ----> unsigned long
  • unsigned long long int ----> unsigned long long
• 11个类型指定符：
  • char、short、int、long、signed、unsigned、_Bool 、void、float、double、_Complex
• 类型只有一种写法，不存在多种写法，每个类型本身只有一个名字
• 用于声明变量的不是类型，而是类型所对应的“类型指定符”
• 一个类型，可能对应着多个“类型指定符”
  • long int类型对应着4种不同的“类型指定符”，分别是：long int、 long、signed long、signed long int

第五节 访问变量如此简单

• unsigned long long int n;//用于存储加数
  unsigned long long int sum; //用于存储运算结果
  unsigned long long int n, sum; //声明变量
  n = 1；//将变量n的值设置为1
  sum = 0; //将变量sum的值设置为0

• “=”：赋值运算符

  • 作用：将位于右边的操作数的值存入左边的操作数中

第六节 运算符、操作数、表达式、子表达式、语句

• 语句：表达式语句、选择语句、循环语句、跳转语句、标号语句、复合语句

• n = 1; //表达式语句  -->  赋值运算符  -->  赋值表达式
  sum = 0;//表达式语句 -->  赋值运算符  -->  赋值表达式

• n 和 1 ----> 赋值运算符的操作数

  • ​ ----> n = 1 的子表达式

• 表达式语句 ----> 表达式；

• 表达式 ----> 运算符、操作数

第七节 循环语句、复合语句

• 循环语句：while循环、do-while循环、for循环

• 具体实现：

  • while(n < = 100)
    {
        sum += n;
        n = n + 1;
    }//复合语句

• 语法规则：

  • while(表达式) 
    {
        循环体   
    }

• 执行流程：

  • 表达式为假则跳过语句，循环结束
  • 表达式为真则执行语句，开始本次循环
  • 语句执行完以后自动跳回表达式，对下一轮循环进行判断

第八节 左值、右值、左值转换

• 左值：可以出现在 ”=“ 左边的东西(一个可以存储数据的容器)
• 右值：可以出现在 ”=“ 右边的东西(一个具体的数值)
• 左值转换：
  • (n <= 100):处理器会将变量转换为所存储的数值，再与100进行比较，这个过程便称为左值转换

第九节 关系表达式、常量表达式、表达式的值、循环原理、最简单表达式

while(n <= 100){
    sum += n;
    n += 1;
}

• 表达式n ≤ 100
  • “≤” ----> 关系运算符 ----> 关系表达式
  • 3个表达式的值：(每个表达式都有一个值)
    • 表达式 n <= 100：运算符的运算结果
    • 表达式 n：变量n中所存储的值
    • 表达式100：(常量表达式)：100
  • "≤"运算符的运算结果判定方法：
    • C语言规定：满足条件时，运算结果 = 1
      • ​ 不满足条件时，运算结果 = 0
  • while循环：
    • 表达式的值 = 0，循环结束
    • 表达式的值 ≠ 0，继续循环
  • 表达式最简单的形式：单独的一个常量或者变量

第十节 加性表达式、运算符的优先级

sum = sum + n;

• “+” 运算符 和 "-"运算符 ----> 加性运算符 ----> 加性表达式
  • 1. 这个表达式到底是“加性表达式”还是“赋值表达式”？
       • 赋值表达式
    2. 中间的操作数sum到底是“赋值运算符”的操作数还是“加性运算符”的操作数？
       • 加性运算符的操作数
• 运算符的优先级：
  • C语言规定，“加性运算符”的优先级，高于“赋值运算符”的优先级
  • 加性运算符的操作数：左边为sum，右边为n
  • 赋值运算符的操作数：左边为sum，右边为sum+n
• 赋值运算符的运算结果怎样判定？
  • C语言规定：赋值运算符的运算结果，就等于左边容器被赋予的新值，或者说等于右边操作数的值

第十一节 运算符的结合性、值计算、副作用

sum = n = 0;

• 运算符的结合性：
  • 左边的优先级高于右边的，称之为“从左向右结合”
  • 右边的优先级高于左边的，称之为“从右向左结合”
• C语言规定：赋值运算符是“从右向左结合”的
  • 右边 “=” 的操作数：左边为n，右边为0
  • 左边 “=” 的操作数：左边为sum，右边为n = 0
• 计算表达式的值，简称“值计算”
  • 主要的目的是为了进行“值计算”，改变变量的值只是附带的一个作用，所以，就把这个现象称之为"副作用"。

第十二节 函数是干吗用的

• 函数：C程序的最基本的组成单元（一个可以完成特定功能的“独立代码块”，在需要的时候我们可以使用“函数调用代码”来调用它）

• //功能代码
  unsigned long long int n, sum;
  n = 1;
  sum = 0;
  while(n <= 100)
  {
      sum = sum + n;
      n = n + 1;
  }

• //函数
  int main()
  {
      unsigned long long int n, sum;
      n = 1;
      sum = 0;
      while(n <= 100)
      {
          sum = sum + n;
          n = n + 1;
      }
      return 0;
  }

• 可将重复使用的功能代码封装为函数，需要用的时候只需执行函数调用代码即可

第十三节 main函数是干吗用的

• main函数是由“初始化代码“来调用的 ----> 操作系统

• 其他函数是由操作者自己写的“函数调用代码”来调用的 ----> 操作者

  • (初始化部分) 最后一件事：调用main函数
    (清理部分) 程序结束
    (main函数、入口点函数) int main(){ unsigned long long int n, sum; n = 1; sum = 0; while(n <= 100) { sum = sum + n; n = n + 1; } return 0; }

  

第十四节 GCC编译器

• 配置环境变量：在环境变量 ----> Path最前面添加G:\Program Files\C\mingw64\bin;

  • 打开控制台，输入gcc -v查看版本信息

• gcc 源文件名.c -o指定可执行程序文件名

第十五节 GDB调试器

• gcc 源文件名.c -o指定可执行程序文件名 -g
  • 如果要对程序进行调试，必须在编译文件的时候添加 -g 选项
  • 作用：给编译得到的可执行文件中添加额外信息辅助操作者完成调试工作
• gdb 可执行程序名.exe -silent
  • 通过- silent选项将前导信息屏蔽
    

第十六节 Code::blocks

• 安装Code::Blocks并配置相关环境
  
  

第十七节 函数的语法结构

unsigned long long int cusum(unsigned long long int r){
    unsigned long long int n, sum;
    n = 1;
    sum = 0;
    while(n <= r){
        sum = sum + n;
        n = n + 1;
    }
    return sum;
}
int main(){
    unsigned long long int x, y, z;
    x = cusum(100);
    y = cusum(150);
    z = cusum(200);
    
    return 0;
}

• main : 程序主入口
• unsigned long long int : 指定返回类型(void)
• cusum : 函数名
  • 一个函数可有多个参数，须在函数名右边的括号进行声明，参数之间使用逗号隔开
    • int cusum(int A, int B)声明有返回值值函数，return语句必不可少
  • 若函数没有参数，在括号内写入void.
    • void cusum(void) ， 若以void声明无返回值函数， return语句可以忽略
• unsigned long long int r : 参数声明(void)
• 函数头：
  • 由指定返回类型、函数名、参数声明组成
• 函数体：{}内的语句
  • 函数体必须为复合语句，必须用{}括起来

第十八节 函数调用运算符、函数调用表达式、实参、形参

unsigned long long int cusum(unsigned long long int r) {
	unsigned long long int n, sum;
	n = 1;
	sum = 0;
	while (n <= r) {
		sum = sum + n;
		n = n + 1;
	}
	return sum;
}

int main(void) {
	unsigned long long int x, y, z;
	x = cusum(100);    //(100)：函数调用运算符(优先级高于赋值运算符)    cusum(100)：函数调用表达式
	y = cusum(150);
	z = cusum(200);

	return 0;
}

• 处理器在运行程序时，会先执行函数调用表达式cusum(100)，再执行cusum函数，将100赋值给r，继续往下执行，得到sum，再将sum的值返回给函数调用表达式cusum(100)，最后将cusum(100)的值sum赋值给x，程序运行结束
• return语句作用：
  • 为函数调用表达式返回一个值
  • 结束函数

第十九节 函数的声明、定义、函数原型的声明

unsigned long long int cusum(unsigned long long int );//声明函数原型
int main(void) {
	unsigned long long int x, y, z;
	x = cusum(100);    //(100)：函数调用运算符(优先级高于赋值运算符)    cusum(100)：函数调用表达式
	y = cusum(150);
	z = cusum(200);

	return 0;
}
unsigned long long int cusum(unsigned long long int r) //函数的声明、函数的定义
{
	unsigned long long int n, sum;
	n = 1;
	sum = 0;
	while (n <= r) {
		sum = sum + n;
		n = n + 1;
	}
	return sum;
}

• 声明函数原型时，参数的标识符可以不写
  • 进行语法检查时，编译器只会检查是否有函数名、参数的类型、数量和函数调用表达式是否能够对应起来，对应语法检查通过，不对应，语法检查报错

第二十节 初始化器

unsigned long long int n, sum;//声明变量
n = 1;//表达式语句
sum = 0;//表达式语句
//声明变量，同时初始化变量；此处的0和1可以理解为初始化器
unsigned long long int n = 1, sum = 0;//此处的“=”不是赋值的含义，可以理解为：n的值来自于1，sum的值来自于0

unsigned long long int x, y, z;//声明变量
x = cusum(100);//赋值表达式语句
y = cusum(150);//赋值表达式语句
z = cusum(200);//赋值表达式语句
//声明变量    初始化器，初始化“=”左边的变量
unsigned long long int x = cusum(100), y = cusum(150), z = cusum(200);

第二十一节 复合赋值运算符、复合赋值表达式

sum = sum + n;  //简单赋值，对应2条机器指令
n = n + 1;
//+=：复合赋值运算符，对应1条机器指令，执行效率更高
sum += n;    
n += 1;

• 复合赋值运算符所组成的表达式叫做复合赋值表达式
  • 每个表达式都有一个值，在含有运算符的表达式中，表达式的值等于运算符的运算的结果
  • C语言规定，复合赋值的运算结果等于复合赋值运算符“+=/-=”左边操作数被赋予的新值

第二十二节 前缀++、后缀++

n++; //后缀递增运算符，表达式等于n进行递增之前的值
++n; //前缀递增运算符，表达式等于n进行递增之后的值

int a = 0, b = 0;
a = ++a;  //a = 1
b = b++;  //b = 0

• 表达式被用来做值计算，改变表达式的值只是在进行值计算时带来的一个副作用，上述两个表达式执行后的副作用是相同的，但值计算的效果是不同的，

第二十三节 初识“复杂表达式”

sum += n;
n++;

sum += n ++;  //sum += ++n;

• sum += n ++; //5050
• sum += ++ n; //5150

第二十四节 逗号运算符、逗号表达式

while(sum += n ++, n <= r); 

• 逗号表达式：sum += n ++, n <= r
  • 执行流程：
    • 先处理","运算符的左操作数，再处理右操作数
    • C语言规定","表达式的值等于右操作数的值
    • 只有一个";"，是空语句

第二十五节 等性运算符、等性表达式、逻辑取反运算符、逻辑取反表达式

while(r)
    sum += r --;

• -- : 递减运算符(前缀、后缀)
• r不仅作为循环条件，而且为函数体提供加数

while(r != 0)
    sum += r --;

• != : 等性运算符（不等于），优先级高于逻辑取反运算符

• r != 0 : 等性表达式

• 值的判定：

  • 条件成立 ----> 值 = 1
  • 条件不成立 ----> 值 = 0

• == : 等性运算符（恒等于）

• r == 0: 等性表达式

• 值的判定：

  • 条件成立 ----> 值 = 1
  • 条件不成立 ----> 值 = 0

while(!r == 0)
    sum += r --;

• !: 逻辑取反运算符（一元运算符，只有右操作数）
• 值的判定：
  • 操作数的值 = 0 ----> 值 = 1
  • 操作数的值 != 0 ----> 值 = 0

第二十六节 初识if语句

//使用if语句对传递的参数的值来做一个限制
if(r <= 1000)
    while(r)
        sum += r --;

• if(表达式) 语句
  • 表达式的值 = 1：执行语句
  • 表达式的值 != 0 : 不执行语句
• if (表达式) //单重选择
  • 复合语句；

第二十七节 if、if-else、if-else if

int main(){
    int a = 0, b = 0, c = 0, d = 0;
    if(0)  //常量0，处理器在进行调试时不会执行
        a = 1;
    if(a)  //变量表达式，处理器在调试到当前步骤的时候会进行左值转换，但是a的值为0，处理器同样不会执行if函数体的语句
        a = 1;
    
    return 0;
}

• 在添加断点进行调试时，在只声明未赋值处、数字位置处添加断点毫无意义

• if(表达式) //双重选择

  • 复合语句1；

• else

  • 复合语句2；

• if表达式条件满足时，执行复合语句1；条件不满足时，执行复合语句2

• if(表达式) //多重选择，若条件都不满足，则都不执行

  • 复合语句1；

• else if

  • 复合语句2；

• else if (或else)

  • 复合语句3；

第二十八节 逻辑或运算符、逻辑或表达式

• || ：逻辑或运算符

  • 操作数都为0，结果为0
  • 只要有一个操作所数的值不为0，结果为1

  int a, b, c, d, e;
  
  a = 0 ||0 ;  //0
  b = 1 ||0 ;  //1
  c = 0 ||1 ;  //1
  d = 1 ||1 ;  //1
  e = 3 ||0 ;  //1
  // 保证参数为1-1000以内的数才进行累加
  if(r == 0 || r > 1000)
      return 0;
  else
      while( r )
          sum += r --;

第二十九节 逻辑与运算符、逻辑与表达式

• && ：逻辑与运算符

  • 操作数都为1，结果为1
  • 只要有一个操作所数的值为0，结果为0

• int a, b, c, d, e;
  
  a = 0 && 0 ;  //0
  b = 1 && 0 ;  //0
  c = 0 && 1 ;  //0
  d = 1 && 1 ;  //1
  e = 3 && 9 ;  //1
  // 保证参数为1-1000以内的数才进行累加
  if(r == 0 || r > 1000)
      return 0;
  else
      while( r )
          sum += r --;

• r == 0 || r > 1000
  r == 0 && r > 1000       

• 在逻辑与和逻辑或运算中，处理器一定会优先处理逻辑与、逻辑或运算符的左操作数

• 对于逻辑或运算来说，处理器处理完左操作数后，得到表达式的值为1，则不会继续处理右操作数

  return 0;
  else
  while( r )
  sum += r --;