• 前端
  • 对元素的事件绑定

前端

对元素的事件绑定

• 对于同一个浏览器, 同一个网页, 同一个元素, 可以绑定click事件, 但不能绑定dblclick
  有些网页两者皆可, 有些网页则偏偏不能dblclick

• 代码示例
  $0.addEventListener("click", ()=>{alert(1)})
$0.addEventListener("dblclick", ()=>{alert(2)})

• 页面举例
  所有的微信文章均不可dblclick: 样例网页
  大部分网页还是两者均可的: 样例网页

• 问题补充
  对于一个元素, 可以在控制台查看绑定在其上的事件监视器
  在正常网页绑定click和dblclick事件后, 可以在控制台查看到两个事件
  但在微信文章中, dblclick事件绑定指令会被忽略(click和mousedown事件仍然有效), 似乎有针对性的屏蔽了dblclick事件

目录

• 简述
• 亮点
• 待完成的一些功能
• 更新日志
• 借鉴的灵感和素材

简述

怀着激动的心情, 背书机v2已经初具雏形!
这一次主要的侧重点就在CSS
在动画上费尽心思, 最后的效果还是令人满意的
点击右侧链接开始体验吧! -> 背书机v2

亮点

• 全新的排版布局, 明快的配色, 直观的操作方式
• 丰满的CSS动画设计, 舒适的操作体验
• 可以选择辞书, 可视化创建辞书
• 新增设置面板, 保留偏好设定
• 4款主题色供你选择

待完成的一些功能

• 删除辞书
• “选择类型"尚未制作
• “一言"API导入
• 壁纸相关(设置API/下载壁纸/切换壁纸)
• 更简单易懂的输入格式
• 快速添加一个新的问题-答案组合
• 用户自定义主题色, 以及更多的配色
• 键盘快捷键

更新日志

• 2023年3月23日

  • 表格式输入
  • 格式化内容输入栏变为textarea
  • 更多颜色
  • 从"池子"中抽词

• 2023年3月30日

  • 加入设置, 可以修改池子大小
  • 两个按钮, 随心改变池子的配比
  • 正则表达式, 更轻松的输入
  • 表格式编辑的菜单栏采用sticky
  • 准备搞一套深色模式和一言API

• 2023年4月6日

  • 实现了问题的专属标志! 以问题字符串为原料生成一个唯一的图案辅助记忆
  • 多个单词对比分栏呈现!
  • 输入的格式更加简化, 会对输入预处理, 无需担心输入的是escape形式还是dom形式
  • 实时反映问题频次
  • 优化了全屏按钮(手机上没法实现double click, 还得是按钮来实现)
  • 信息栏的CSS调整
  • 准备让textarea也能全屏输入(实现方法和panel类似, 底部再加一个按钮, 进去之后的两个按钮: 退出全屏, 格式化)
  • 说明部分还没改

• 2023年4月27日

  • 去掉了未完成的全屏化
  • 正则表达式再修改
  • 专属标志再优化

• 2023年5月20日

  • 标志再优化: 更居中 更大 更合适的比例 透明的颜色表现重叠效果
  • 单词重复率记忆(但没有设置手动修改的地方, 下次在列表修改旁边再加一列, 否则有的单词变0就再也修改不了了, 同时辞书更新后重复率也要更新)
  • bug修补(因为pool没清空导致好几次新单词刷不出来)

借鉴的灵感和素材

主要来源是17素材网

• 页面模板
• hsycmsAlert弹窗插件
• 选择辞书的卡片式多选框
• 子标签
• 高级感按钮

• 自制超星刷课脚本
• greasyfork油叉链接

目录

• 自定义脚本
• 脚本推荐
• 油猴脚本

自定义脚本

• 以下是本人自己写/修改的一些脚本, 从这些url可以安装使用
• 由于要应对个性化需求, 有好的想法可以联系我, 尝试实现后发布上来供读者使用
• 编写脚本对js/css/html有一定要求, 本人只能触其皮毛, 仅以方便使用为目的

脚本推荐

油猴脚本

• 简介:

Greasemonkey，简称GM，中文俗称为“油猴子”，是Mozilla Firefox的一个附加组件。它让用户安装一些脚本使大部分HTML为主的网页于用户端直接改变得更方便易用。
–摘自 百度百科

简而言之, 油猴脚本是一个脚本平台, 可以自行安装多个脚本, 每个脚本可以针对需求改变网页样式.
强力的脚本可以达到意想不到的效果 (例如, 将非会员改为会员)
总之, 优秀的油猴脚本能为生产生活带来的极大的便利

• 使用介绍:
  • 关于安装方法, 这篇油猴插件及油猴脚本使用手册（完整版）写的挺周延了, 推荐参考
  • 安装可以通过Chrome的插件商店, 当然度娘直搜也会提供很多crx安装的方式, 本文不赘述
  • 插件安装完成后, 有三种基本方式来安装插件
    1. 按油猴的标志, “获取新脚本”, 到search网站搜索, 在Greasy Fork中安装插件
    2. 从其他网站上下载了xxx.user.js一类的脚本文件后, 直接拖动到Chrome窗口, 油猴自动识别安装
    3. “添加新脚本”$\leftarrow$直接自己写脚本
  • 大多数脚本会应对针对的问题的变化而更新, 建议开启定时更新
  • 脚本根据用途的不同会有自定义设置, 按油猴标志可以选择开关脚本的部分功能, 或者禁用/启用脚本
  • 网上搜油猴脚本会有大量推荐, 大多都是优质脚本
    当然, 要满足特定的个性化需求, 这些还是不够的

• 简介
• Windows API
  • 程序的入口
  • 可能遇到的问题和实现

简介

ACLLib是一个基于Win32API的函数库, 提供了相对简单的方式来制作Windows程序
实际提供了.c和.h两个文件

Windows API

API (Application Programming Interface)中文名是 应用程序编程接口
因为当第一个32位的 Windows 出现就有了API, 因此也叫做 Win32API

即便Windows发生了天翻地覆的变化, 其核心机制仍旧不变

这个库由纯C语言编写, 一些早期的Windows程序就是由ta写就

程序的入口

为什么平日里我们要将main作为程序的入口?
这并非是C语言本身所要求的, 而是编译器决定的

当启动程序的时候, 由操作系统将可执行程序装载到内存中
启动运行, 运行的第一条指令是启动代码
这个 启动代码 是编译器创建的
作用就是去寻找main

对于Win32API来说, 启动代码的入口函数是WinMain()

可能遇到的问题和实现

• 字符串
  • 标识字符串
  • 字符串的使用
• 使用说明
  • 列出模块中的函数
  • 函数说明
  • 打印文档字符串

字符串

标识字符串

有三种方式:

• 单引号:
  • a='She said"Yes!"'
  • 字符串的内容中允许有双引号
• 双引号:
  • b="I'm fine."
  • 字符串的内容中允许有单引号
• 三引号:

  • c="""
    There're some "words"
    in these two lines.
    """
    

  • 字符串的内容中允许有单/双引号, 也会保留多行内容

单独的三引号是文档注释

字符串的使用

非常灵活, 非常人性化 以下是一些例子

>>> "ha"*5+"!"*3
'hahahahaha!!!'

使用说明

列出模块中的函数

dir(m)可以以数组形式, 列出改模块中所有的函数名

>>> import math
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']

>>> dir(__builtins__)会展示所有 内置函数

带有双下划线的内容一般用于较为复杂的编程, 可以先忽略

函数说明

help(function)打印出改函数的使用说明

打印文档字符串

print(fucntion.__doc__)

>>> print(sin.__doc__)
Return the sine of x (measured in radians).

• type
  • 整数
  • 浮点数
  • 数组
  • 字符串
  • 复数
• 取地址
• 函数

type

type(x)返回x的类型 一共有 五大序列

整数

>>> x=1
>>> type(x)
<class 'int'>

浮点数

>>> x=.5
>>> type(x)
<class 'float'>

数组

>>> x=[1,2,3]
>>> type(x)
<class 'list'>

字符串

>>> x='''Tom said,\n "Let's go!"'''
>>> x
'Tom said,\n "Let\'s go!"'
>>> print(x)
Tom said,
 "Let's go!"
>>> type(x)
<class 'str'>

复数

>>> 1j*1j
(-1+0j)

取地址

id(x)返回一个代表地址的整数

注意, 修改变量的值地址也会改变

函数

ord(x)获得ASCII码
dir(import)列出库中对象
help(fun)获得函数的说明

• 运算
  • 整数运算
  • 浮点运算
    • 溢出
    • 精度问题
  • 复数
  • 数学函数
    • 常用的数学函数
    • 导入库
• 类型转换
  • 显式转换
  • 隐式转换

运算

整数运算

python对于整数的长度不设限制

浮点运算

浮点数是指带有小数点的数字, 浮点数参与的运算就是浮点运算
所有整数运算符都适用于浮点运算

小数的写法非常灵活:

• >>>3.
3.0
• >>>.5
0.5
• >>>2.3e02
230.0

注意: 5和5.0完全不一样
前者是整数, 后者是浮点数
其内部表示大相径庭

溢出

浮点数存在上下限, 超出会导致溢出错误

>>> 500.0**99999
Traceback (most recent call last):
  File "<pyshell#18>", line 1, in <module>
    500.0**99999
OverflowError: (34, 'Result too large')

注意: python有可能会对这类错误沉默不语
溢出产生的错误由程序员自己承担

精度问题

浮点数 精度有限

>>> 1-2/3
0.33333333333333337

细微错误的不断累积可能导致灾难

复数

很少涉及

>>> 1j*1j
(-1+0j)

数学函数

常用的数学函数

导入库

方法一:
>>> import math
要使用math库的函数, 需要在函数名前面放上math.

方法二:
>>> from math import * 这样在调用的时候就不需要在函数名前面加上math.了

方法一比较安全, 不会和已有的函数名冲突

方法二还可以只导入特定的函数, 如:
>>> from math import sin, cos, tan

类型转换

显式转换

>>> int(2.6)
2
>>> float(3)
3.0
>>> str(85.6)
'85.6'

隐式转换

• 可变数组
  • 思路
  • 实现
    • 定义结构
    • 创建数组
    • 释放数组
    • 数组大小
    • 获得指定单元的地址
    • 数组的增长
• 链表
  • 概述
  • 实现思路
  • 程序实现
    • 定义节点的结构体
    • 增加一个节点到链表末尾
    • 链表的遍历
    • 链表的检索与删除

可变数组

思路

C语言中, 数组被一旦定义就无法改变其大小
如果想得到一个"可变数组", 应当有一下特点:

• 可以增长
• 要能知道当前数组确切的大小
• 要有方便合理的方法访问到其中的单元

考虑创建一系列实现特定功能的函数库:

• 创建这样的数组: Array array_create(int init_size);
• 释放数组: void array_free(Array *a);
• 获得数组大小: int array_size(const Array *a);
• 获得指定单元的地址: int* array_at(Array *a, int index);
• 扩大数组的空间: void array_inflate(Array *a, int more_size);

实现

定义结构

typedef struct {
    int *array;
    int size;
} Array;

其实, 可以直接定义*Array指针, 原因是函数调用基本都要求传指针, 直接定义为指针会显得方便美观
但是, ta有两个严重的弊端
首先, 阅读代码的人, 很难察觉这是一个指针
其次, 无法在局部范围内, 定义出一个Array

因此, 还是老老实实的定义本体

创建数组

Array array_create(int init_size)
{
    Array a;
    a.size = init_size;
    a.array = (int *)malloc(sizeof(int) * a.size);
    return a;
}

释放数组

void array_free(Array *a){
    free(a->array);
    a->array = NULL;
    a->size = 0;
}

后面两行是出于保险起见

数组大小

int array_size(const Array *a){
    return a->size;
}

为什么如此简单的事情还要额外创造一个函数?
这个做法有个专门的称呼: 封装
封装函数极为有用, 为后期的修改提供了可能
例如, 如果后来开发中, 要得到size必须先通过一段保护程序
那么就可以在这个封装函数中修改
而且外部不知道具体如何实现, 对size形成了保护
而如果每次都采用直接调用, 那么要耗费大量精力做修改, 这是很划不来的

获得指定单元的地址

int *array_at(Array *a, int index){
    return &(a->array[index]);
}

为什么要的是指针?
因为这样可以 访问 这个元素
这意味着既能读取又能写入

考虑到在函数前加星号*可能会引起不适
可以再添加一对函数(名字可以是read和set), 来实现同样的功能
这么做繁琐, 但是增强了可读性, 当然, 直接获取指针其实也还行

数组的增长

简要来说, 就是: 申请一块新的, 把旧的释放掉

void array_inflate(Array *a, int more_size)
{
    int *p = (int *)malloc(sizeof(int) * (a->size + more_size));
    int i;
    for (i = 0; i < a->size; i++)
    {
        p[i] = a->array[i];
    }
    free(a->array);
    a->array = p;
    a->size += more_size;
}

什么时候要增长数组呢?
当我们访问一个元素的时候, 发现下标超出了数组的大小, 就意味着数组不够用了
因此改进array_at方法:

int *array_at(Array *a, int index)
{
    if(index>=a->size){
        array_inflate(a, ((index / BLOCK_SIZE) + 1) * BLOCK_SIZE - a->size);
    }
    return &(a->array[index]);
}

为什么有BLOCK_SIZE?
设想我们的数组撑满了, 此时需要再往里填一些数(比如在读入数据的时候)
那么如果增长的大小为index - a->size
即便只是读入一个数句, 就要调用一次array_inflate函数
要知道, 这意味着数组重新复制一遍, 无异于大动干戈

因此最好的做法是一次增长 “一块"空间
比如说一次就增长5的倍数大小的空间
这样做最经济高效

为此, 我们还要在文件的前面添上常量声明:

const BLOCK_SIZE = 5;

如何理解 ((index / BLOCK_SIZE) + 1) * BLOCK_SIZE呢?
其实就是向上取整
如果index是2, 那么就是5
如果index是67, 那么就是70
保证数组的大小总是BLOCK_SIZE的整数倍

链表

概述

自动增长的数组是一个很有用的工具
但是, ta最大的缺点在于: 每次都要申请一个能容纳全部元素的新的空间
这会导致两个问题:

拷贝一次要花很多时间

当数组中的总数据量比可用空间的一半要多的时候, 明明可以容纳下, 但没法再申请空间了

链表, 就是不再拷贝数组, 当数组不够用的时候, 开辟一块新的空间, 并用一个指针将两者"链接"起来
这么做不但在时间上高效, 而且还能充分利用到可用空间的角角落落, 空间使用上也高效

实现思路

每一个储存单元包含一个 int 数组和一个 int 指针
其中:

• 第一个储存单元要能表示自己是第一个, 要有个head标志
• 中间每个指针都指向下一个单元的地址
• 最后一个指针也要有个表示, 表明自己是最后的末尾

这样的每个单元被称为 节点(node), 整个这一系列的节点被称为 链表(linked list)
当我们要读入 未知数量的 数据时, 应当有下列的行为:

• 先Node *head = NULL定义一个头部节点, 代表着有这么一个链表存在
• 当有数据进入时申请空间, 创建一个新的Node
• 把数据导入这个节点的value中, 并将*next指针设定为NULL(因为新节点添加在链表的末尾, 因此用指针指向NULL表示)
• 找到链表的最后一个节点
  • 先定义一个Node *last指针, 让ta的初始指向为*head一致

    这里还需要判断一下, *last是不是就是*head

  • 看*last指针指向的Node对应的*next是不是NULL
  • 不是的话用循环继续找下去
  • 是的话, 就说明此时这个*last指向的就是最后的节点了
• 把最后的节点的*next改成 现在新添加的这个Node的地址, 即, 实现了 链接

程序实现

定义节点的结构体

typedef struct _node{
    int value;
    struct _node *next;
} Node;

注意一个细节, 观察下面这段错误代码和上面的正确的代码的区别:

typedef struct _node{
    int value;
    Node *next;
} Node;

区别在于定义结构指针的时候用_node还是声明好的结构Node
注意, 编译器在第三行声明成员变量的名称时, 还 “不认识” Node是什么
但如果改写成struct _node, 编译器是知道的
在那之后再将struct _node定义成Node(两者等价)

P.S.这个做法很常见

增加一个节点到链表末尾

把方才实现思路中, **“添加一个新节点到链表最末尾”**这个功能抽离封装为函数

void add(Node *head, int number)
{
    Node *p = (Node *)malloc(sizeof(Node));
    p->value = number;
    p->next = NULL;
    Node *last = head;
    if (last)
    {
        while (last->next)
        {
            last = last->next;
        }
        last->next = p;
    }
    else
    {
        head = p;
    }
}

但这个粗糙的函数有个问题, 那就是head = p这处要求改变传入的head, 而由于在函数中, 因此不奏效
有多种方法可以解决:

1. 用全局变量
2. 用 return 返回一个head
3. 传入一个head的地址(指针的指针)
4. 自定义一个新的结构, 这个结构中包含的成员变量是Node的指针

前几种容易考虑到, 着重分析一下第4个方法:
先要额外定义一个结构_List

typedef struct _List{
    Node *head;
} List;

接着修改函数, 传入一个List的指针List *pList以修改函数外的变量
再将head改成pList->head, 得到最终的版本:

void add(List *pList, int number)
{
    Node *p = (Node *)malloc(sizeof(Node));
    p->value = number;
    p->next = NULL;
    Node *last = pList->head;
    if (last)
    {
        while (last->next)
        {
            last = last->next;
        }
        last->next = p;
    }
    else
    {
        pList->head = p;
    }
}

为什么要这么做呢?
因为, 用一个自己定义的List结构来容纳head这个node的指针
在阅读上更容易接受, 节点不再单独出现, 更有链表的样貌
此外, 这么做还能允许后期加入更多的功能

例如, 为了寻找链表的尾巴, 每次都需要做一个循环
那么就可以在这个List结构中加入Node *last
每次添加新的Node之后更新last, 高效且易懂

链表的遍历

用一个循环搞定

Node *p;
for (p = list.head; p; p=p->next)
{
    printf("%d\t", p->value);
}

封装为函数:

void pirnt(List *pList)
{
    Node *p;
    for (p = pList->head; p; p = p->next)
    {
        printf("%d\t", p->value);
    }
    printf("\n");
}

链表的检索与删除

检索就是在遍历的过程中比较value和目标值
实现删除有如下步骤:

• 把前面Node的指针指向后面的Node
• free当前的Node

问题在于, 无法获知 上一个Node
考虑再加一个指针, 记录上一个Node

void delet(List *pList, int number)
{
    Node *p, *q;
    for (q = NULL, p = pList->head; p; q = p, p = p->next)
    {
        if (p->value == number)
        {
            if (q)
            {
                q->next = p->next;
            }else{
                pList->head = p->next;
            }
            free(p);
            break;
        }
    }
}

一定要检查边界条件!
任何在->左侧的指针必须要检查是否为NULL

• 位运算
  • 按位运算
    • 按位取与
    • 按位取或
    • 按位取反
    • 按位异或
  • 与逻辑运算的区别
  • 移位运算
    • 左移
    • 右移
    • 误区
• 举例–输出一个数的二进制
  • 实现思路
  • 代码实现
• 位段
  • 背景介绍
  • 代码实现
  • 利用结构体创造位段
    • 定义一个结构体
    • 为结构体赋值并查看结果
    • 优缺点

位运算

C语言中有如下位运算的运算符

按位运算

按位取与

定义: 对于第i位, 如果两数都为1, 则与的结果为1, 否则为0
口诀: 同真则真, 一假则假
应用:

• 让某一位为0: 对于x, 要使得其末位为0, 则计算x & 0xFE
• 截取一个数的某一段: 对于一个int x, ta有4个字节, 如果只要最后一个字节的内容, 则计算x & 0xFF

按位取或

定义: 对于第i位, 如果两数都为0, 则与的结果为0, 否则为1
口诀: 一真则真, 同假则假
应用:

• 让某一位为1: 对于x, 要使得其末位为1, 则计算x | 0x01
• 拼接两个数: 对于两个一个字节的数0xAB和0xCD, 计算0xAB00 | 0x00CD可以得到拼接的结果0xABCD

按位取反

定义: 每个比特的值翻转
口诀: 一变零, 零变一
应用:

• 让某一位为1: 对于x, 要使得其末位为1, 则计算x | 0x01
• 拼接两个数: 对于两个一个字节的数0xAB和0xCD, 计算0xAB00 | 0x00CD可以得到拼接的结果0xABCD

补码与取反不同!
补码是在原码取反后+1
补码可以看做原码的负数

按位异或

定义: 两个位相等则结果为0, 不相等则为1
口诀: 同则零, 异则一
应用:

• 加密: 对一个数用同一个值异或运算两次, 仍得到原来的数
  x ^ y ^ y -> x

与逻辑运算的区别

计算机底层只有按位运算
所谓逻辑运算其实就是将任何非0的数看做1, 然后做按位运算

移位运算

左移

定义: i << j将i中所有的位向左移动j个位置, 右边填充0

所有小于int的类型, 移位的结果均为int
(可能会因为编译器而有不同)

注意, 可能会把signed类型的符号位挤掉

x <<= n等价于x *= (int)pow(2.0, n)

右移

定义: i >> j将i中所有的位向右移动j个位置

• 对于unsigned类型, 左边填0
• 对于signed类型, 左边填原来的最高位(即表示符号的那一位)

所有小于int的类型, 移位的结果均为int
(可能会因为编译器而有不同)

x >>= n等价于x /= (int)pow(2.0, n)

误区

不要以为x << -2等价于x >> 2!!!
这个行为未被定义, 会报错

举例–输出一个数的二进制

实现思路

用一个unsigned的mask去查看这个数字每一位是0还是1
mask只有一个位上有1, 其余位皆为0
那么和要算的数字运算按位取与
如果那一位是0, 那么结果是0, 否则就是1

代码实现

void printBin(int number){
    unsigned mask = 1u<<31;
    for (; mask;mask>>=1){
        printf("%d", (number & mask) ? 1 : 0);
    }
}

位段

背景介绍

在单片机中, 需要给芯片做一些设置
这些设置是通过一个二进制数读入的
为了容易理解, 以下将这个二进制数类比为一连串手势
手势的含义在单片机的手册中有明确规定
比如, 规定, 这个二进制数的第3位如果是1, 其含义就是"开启某功能"
这个二进制数的第3位如果是0, 其含义就是"关闭某功能"
当然, 还有可能出现"第4和第5这两个位置上0/1组合出的4种情况对应某个功能的4个模式"

我们的目标是, 运用位运算, 将给定的一个二进制数中的某几位, 修改为0或1

题目: 有一个unsigned二进制数, 要求将从右往左数的第2和第3位比特变成1, 第4位比特变成0

代码实现

const unsigned int origin = 0b111000;
unsigned int result = 0b111000;
const unsigned int flag2 = 1u << 1; //注解1
const unsigned int flag3 = 1u << 2;
const unsigned int flag4 = 1u << 3;

result |= flag2 | flag3; //注解2
result &= ~flag4; //注解3

printBin(origin);
printf("\n");
printBin(result);

注解1:
为什么要用const?

因为这个既然是开关, 那么在后续的程序中修改还会用到
方面后面的使用

另外还要注意, 1u所指就是第一位比特
所以为了对应第二位比特, 只需左移一位

注解2:
这里其实先运算等号右侧的表达式, 其结果是0b110
也就是两个开关并在一起

然后|=是一个简写, 就是按位取或之后再赋值
由于只有指定的两个比特是1, 对于其他比特没有变动
而对于指定的两位, 一定变1, 达到效果

注解3:
和上面一样, 不过这一次是先要按位取反
这样得到的结果除了指定的位置是0其余都是1
运算按位取与, 和1取与结果就是不变
而和0取与必定是0, 同样达到效果

利用结构体创造位段

考虑到结构体中的成员就是直接排列在一起的
用结构体可以更轻松容易的实现上述效果

定义一个结构体

struct U0
{
    unsigned int leading : 3;
    unsigned int FLAG1 : 1;
    unsigned int FLAG2 : 1;
    unsigned int trailing : 27;
};

这里冒号:后的数字代表这个成员所占的比特数
其中:

• leading代表前三个比特, 能表示8种不同的选项
• FLAG1和FLAG2可能代表两个开关
• trailing是尾巴的含义, 其作用是为没用到的比特初始化赋值

为什么trailing是27比特呢?
因为总的比特数加起来是32, 刚好是4个字节, 即一个int的大小
一般来说就是一个位段的单元

为结构体赋值并查看结果

struct U0 uu;
uu.leading = 5;
uu.FLAG1 = 0;
uu.FLAG2 = 1;
uu.trailing = 0;
printBin(*(int *)&uu);

这里leading部分可以直接赋十进制的数
因为在内存中都是二进制

注意输出时的操作: *(int *)&uu
uu是一个结构变量, 无法直接取出内存中的二进制储存
这里是典型做法:

1. 先取其地址
2. 强制类型转化为int类型的指针
3. 取这个int指针的值

最终结果符合预期

优缺点

优点:

• 可以直接通过位段的成员名称访问目标值

缺点:

• 结构中位的排列方式是由编译器决定的(大端小端)
  因此不具有可移植性

• 格式化输入输出
  • 输出的格式字符串
    • flags
    • width和.prec
    • h|L
    • type
  • 输入的格式字符串
    • flag
    • type
  • printf和scanf的返回值
• 文件的输入输出
  • FILE
    • 操作文件的函数
    • 打开文件的标准代码
  • 函数
    • fopen
• 二进制文件
  • 选择文本文件还是二进制文件的历史
  • 文本文件和二进制文件的比较
  • 程序运行为什么需要文件
  • 操作二进制文件
    • 读写
    • 定位
  • 可移植性问题

格式化输入输出

输出的格式字符串

格式字符串有4个可选的参数
完整的格式字符串是这样的:
%[flags][width][.prec][h|L]type

flags

flags是一个标志, 控制数字输出的样式
有这样一些可选项

注意, 一个格式字符串可以有很多flags
这些flags的先后顺序无关紧要
例如printf("%+-9d",123);就会输出左对齐的+123
但是, 左对齐, 正数留空 和 用零填充 这三个需求是冲突的, 只能出现一个

width和.prec

width是一个正整数, 表示输出的数字总共所占据的字符的个数
.prec是加在width前面的小数点, 表示输出的数字保留小数点后的个数

注意:

• %9.2d表示总共是9个字符位, 小数点后保留两位

不要把%9.2d误当做是小数点前有9位的意思!

• width还可以是一个星号*, 让一个参数传入来作为width的值

举例:

int len1 = 10;
int len2 = 2;
printf("下面这个数字共%d位, 保留了%d位小数点\n->|%+0*.*f|-<", len1, len2, len1, len2, 123.4);

其输出为:

下面这个数字共10位, 保留了2位小数点
->|+000123.40|-<

h|L

h|L是对类型的修饰

事实上并未生效, 能生效的只有h和l两个
hh要实现的效果似乎可以直接用c替代, 就是输出最短的数据类型
这里有个有趣的现象: printf("%c", 12345);输出的结果是9

这是因为12345在内存中储存为16进制的形式0x3039
只取最后一位, 以字符形式输出就是9

type

汇总一下所有的类型

int num=0;
printf("->|%d|<-%n\n", 12345, &num);
printf("%d", num);

输出结果是:

->|12345|<-
11

笔者在VSC没有成功生效(虽然但是也没warning)

输入的格式字符串

相较于输出, 输入可选的参数比较简单
其格式字符串是这样的: %[flag]type

flag

举例:

int num=0;
scanf("%*d%d", &num);
printf("%d", num);

输入输出:

输入: 12345 67890  
输出: 67890

type

举例1:

int n1 = 0;
int n2 = 0;
scanf("%i%i", &n1, &n2);
printf("%i %i", n1, n2);

输入输出:

输入: 0xab 012
输出: 171 10

举例2:

char n1[20] ;
char n2[20];
scanf("%*[^:]:%[^,],%[^.]", n1, n2);
printf("%s %s", n1, n2);

输入输出:

输入: 输入了两个数字:123,456.
输出: 123 456

这里的[^:]是指: 在第一个:前(不包括:)所有的内容(视为字符串)
其他两个[^,] [^.]同理
分析一下这里的输入格式字符串:

• 首先, 跳过封号:前所有内容
• 读入封号:
• 读入逗号,前所有内容, 作为字符串交给地址n1
• 读入逗号,
• 读入句号.前所有内容, 作为字符串交给地址n2

[...]的作用不止这一个, 但网上一下子搜不到相关知识点orz
有一篇blog讲的较为详细, 链接-> c语言学习笔记第四章——字符串和格式化输入、输出

printf和scanf的返回值

printf会返回成功输出的 字符数
scanf会返回成功读入的 项目数

在较为严格的项目中, 应当判断每次输入输出的返回值
以确保程序运行中不会产生问题

举例:

int num = 0;
int s = 0, p = 0;
s=scanf("%i", &num);
p=printf("%i\n",num);
printf("scanf返回值:%d\n",s);
printf("printf返回值:%d\n",p);

输入: 0xabc
输出:

0xabc
2748
scanf返回值:1
printf返回值:5

这里返回值为5, 因为回车符也算在其中

文件的输入输出

FILE

FILE是标准库中定义的结构
常用的是文件指针: FILE *

该结构的其他成员用来反映文件的相关信息

操作文件的函数

• fopen函数打开指定文件, 并返回一个FILE指针
  FILE * fopen (const char * restrict path, const char * restrict mode);
• fclose函数关闭文件
  int fclose (FILE * stream);
• fscanf函数负责从文件中读入
  int fscanf(FILE *__stream, const char *__format, ...)
• fscanf函数负责向文件中写入
  int fprintf (FILE *__stream, const char *__format, ...)

打开文件的标准代码

FILE *fp = fopen("file", "r");
if (fp)
{
    fscanf(fp, ...);
    /* handler */
    fclose(fp);
}
else
{
    /* fp == null */
    printf("无法打开文件\n");
}

如果找不到文件, fopen函数会返回null

函数

fopen

fopen的第一个参数是文件的路径
第二个变量是打开文件的方式, 下面这个表格是所有可选的方式

二进制文件

所有文件最终都是二进制的
文本文件可以通过简单的方式实现读写
但是二进制文件需要专门的程序来实现读写

选择文本文件还是二进制文件的历史

Unix 喜欢使用文本文件来做数据存储和程序配置

由于交互式终端的出现(在Unix之前), 人们更倾向于使用文本与计算机"talk"(交互)

Unix的shell提供了利于读写文本的小程序, 因此使用文本很方便

Windows喜欢使用二进制文件

DOS操作系统的发明来源于草根文化, 是设计者革新的发明, 完全出自对于计算机硬件的理解
因此, DOS并不继承Unix的特点

用二进制的方式做输入输出更接近底层

文本文件和二进制文件的比较

文本文件:

• 优点
  • 方便人类读写
  • 跨平台(到哪儿都能用)
• 缺点
  • 输入输出需要格式化
  • 运算和处理的开销较大

二进制文件:

• 缺点
  • 输入输出是直接的
  • 程序读写无需计算, 速度很快
• 缺点
  • 人类读写困难
  • 不支持跨平台(例如int这样的类型在不同操作系统中的长度不一样, 还有可能涉及到大小端的问题)

程序运行为什么需要文件

1. 配置信息
   • Unix采用文本
   • Windows用注册表记录

注册表是一个很大的二进制文件, 所有文件的配置信息全部记录在其中

2. 数据存储
   • 量大的数据可以使用数据库很轻松的存储
3. 媒体文件
   • 媒体文件只能是二进制文件

事实上, 程序基本都通过第三方的库来实现对文件的读写
很少直接读写二进制文件

操作二进制文件

读写

实在要直接处理二进制文件, 则采用以下这对函数:

size_t fread (void * pointer, size_t size, size_t nitems, FILE * stream);
size_t fwrite (const void * pointer, size_t size, size_t nitems, FILE * stream);

参数表:

1. 指针, 指向要读写的内存
2. 这块内存的大小
3. 有几个这样的内存
4. 文件指针

返回值 的是成功的读写的字节数

第三个参数nitems( number of items )的作用是什么?
一般对二进制文件的读写都是通过对一个结构变量的操作进行的
nitems就是用来说明这次读写操作几个结构变量

定位

• 得到现在文件中的位置(从文件开头到现在位置的字节数)
  long ftell (FILE * stream);
• 定位到指定的位置 int fseek (FILE * stream, long offset, int whence);

fseek这个函数有三个参数:

1. stream是FILE指针
2. offset是偏移量, 也就是数到第几个字节
3. whence是寻找的方式, 有三个选项(都是预定义的宏, 所以表现出来的是int)

• SEEK_SET: 从头开始找
• SEEK_CUR: 从当前位置开始找
• SEEK_END: 从尾巴开始从后向前找

一般从二进制文件中得到结构个数的方式如下:
用fseek(fp, 0L, SEEK_END);可以移动到末尾(这里的0L是将数字0作为长整型Long的表达方式)
然后再用long size = ftell(fp);就可以得到从头到尾的字节数
用这个size除以每一个结构的大小就可以得到这个文件中的结构个数

可移植性问题

二进制文件不具有可以执行性

int在32位机的字节数与64位机的不一致
读写就是错误的

解决方案之一是放弃使用int
转而使用typedef人为定义出具有明确字节数的自定义类型
当然, 更好的方案还是使用文本

• 编译预处理
  • 编译预处理指令
  • 预处理时究竟发生了什么
• 宏
  • 定义宏
  • 使用宏
  • 没有值的宏
  • 预定义的宏
  • 像函数的宏
    • 易错点
    • 特点
• 大程序结构
  • 多个C文件
  • 编译单元
  • IDE
• 头文件
  • 使用
  • 预处理指令
  • 使用的细节
  • 误区
  • 头文件的使用规范
    • 不对外公开的函数和全局变量
• 全局变量
  • 声明
  • 声明和定义
• 头文件那些事儿
  • 规则
  • 问题
  • 标准头文件结构

编译预处理

编译预处理指令

所有预处理指令都以#开头

“#“对应的英文是"pound”
电话键盘上的”#“则是"hash”

注意: 编译预处理部分并不是C语言的成分(例如include不是C语言的关键字), 但是C语言程序离不开他们

预处理时究竟发生了什么

编译C语言代码时, 编译器会产生一系列临时文件
按照顺序来看, .c->.i->.s->.o->.exe

• 第一步, 首先编译预处理, 所有预处理完成后产生.i中间结果文件(注释也会被忽略掉)
• 第二步, 真正由C语言编译器编译, 产生.s汇编代码文件
• 第三步, 由汇编代码文件汇编, 产生.o目标代码文件
• 第四步, 根据链接, 将多个目标代码文件链接起来, 产生.exe可执行文件(linux是.out)

宏

定义宏

#define指令的作用是定义宏
#define PI 3.1415926
上面的这个指令定义了一个宏, PI是这个宏的名字, 3.1415926是这个宏的值

可以理解为, PI是个符号, 宏是他的具有高级感的别名

在编译预处理中, 在代码中出现的所有的宏的名字都会被直接替换为对应的值(换言之, 是 原始的/直接的/原封不动 的文本替换工作)

注意

• 宏的定义不是C语言代码, 因此后面不要加;封号

使用宏

• 如果一个宏中有其他的宏的名字, 同样会被替换
• 如果宏的值超过一行, 需要在最后一行之前的行末加上\反斜杠
• 宏的值后面可以写注释, 不会被当做是宏的值

#define HW "Hello world!" // 你好世界
#define PRT                \
    printf("你好世界!\n"); \
    printf("%s", HW)

int main()
{
    PRT;
    return 0;
}

注意观察;
因为在C语言代码中, 每一行指令最后要带有封号结尾
因此宏的名字后面要加封号的话, 宏的值最后不能有封号
但是, 对于这种用来替代成段代码的宏, 其值就是代码
因此该写封号还得写

总的一句, 宏的值最后不能有封号

没有值的宏

这一类宏的存在只想说明一件事: 这个宏被定义过了
会有其他预处理指令通过这一点判断"这个宏是否被定义"
这样就能实现"条件编译"(视情况而编译不同的代码)

预定义的宏

注意, 这里的__LINE__是个整数, 其余都是字符串

像函数的宏

名字中带有圆括号的宏能实现类似于函数的功能
这样的宏可以带有参数
#define cube(x) ((x)*(x)*(x))
注意: 圆括号中的参数 没有类型

这里仍旧是纯粹的文本替换!!!
例如cube(i+5)会转变为:
((i+5)*(i+5)*(i+5))

易错点

这种函数宏很容易犯错!!!
例如#define DOUBLE(x) x+x
在计算3*DOUBLE(2)的时候就会得到8这种错误答案

错误的原因就是被替换的结果是3*2+2, 显然运算优先级被搅乱了

因此, 一切都要带括号

• 整个值要有括号
• 参数出现的每一处都要有括号

此外, 函数宏可以有多个参数, 同样也可以嵌套使用其他宏

特点

带参数的宏在大型程序的代码中使用极为普遍
因为其处理效率比函数更高(更直接), 但代码大小会更大, 是牺牲空间换取效率的方式
在#和##两个运算符的帮助下, 甚至可以实现"产生"函数的功能(函数工厂)
使用宏的习惯上存在着中西方差异(外国人更习惯于使用宏)
宏的弊端是, 宏不会检查数据类型
拓展来说, inline函数可以取代宏的功能(会检查类型)

大程序结构

多个C文件

一个main太长, 于是分出多个函数
一个C源代码太长了, 于是也想分成多个文件
但问题就在于, 多个文件不能直接被编译为可执行文件

一些软件(如Dev C++), 可以新建一个项目, 在项目中加入多个源代码
在编译时, 所有源代码文件都会被链接起来, 编译为一个可执行文件

编译单元

一个.c文件是一个 编译单元
编译器每次编译只处理一个编译单元

IDE

IDE(集成开发环境 Integrated Development Environment)中一般会有两个功能

• 编译(compile) 负责处理一个编译单元, 形成.o文件
• 构建(build) 负责将所有.o文件链接起来, 形成最终的可执行文件

Dev C++是一个传统的IDE, 上述两个功能在这个软件中被合并了

头文件

使用

将函数原型放在一个头文件(.h文件)中

相当于是跨文件的声明

在需要调用函数的源代码(.c文件)中调用时, 在头部加入
#include "function.h"
这么做可以让编译器在编译时检查函数的原型声明

头文件可以看做是个桥梁, 有助于检查函数的原型和使用

预处理指令

#include和宏一样, 也是一个编译预处理指令
也和宏一样, include实质上只是把.h文件原封不动的搬到了.i文件头部的位置

终究只是个搬运工

使用的细节

#include有两种寻找文件的方式
分别是: 双引号"" 和 尖括号<>
其区别是:

• 双引号""会优先在当前目录下寻找文件, 如果找不到, 再到系统路径中寻找
• 尖括号<>直接去系统路径中寻找

因此, 一般来说, 系统标准库提供的头文件使用尖括号<>, 自己定义的头文件使用双引号""

系统指定的目录一般是指环境变量, 且编译器自己知道

误区

#include其实不是用来引入库的, ta只是用来原封不动的搬运代码

.h中只有个原型, 其中定义的如printf这类函数的源代码在某个.lib文件(Windows)或是.a文件(Unix)中
在编译时, 这些东西会由编译器自动链接进去

这也就解释了, 为什么, 不引入头文件使用函数, 只会warning但函数仍旧正常工作
这是因为只是原型丢失(给warning), 编译器会去猜原型, 正好猜中了, 于是正常运行

之所以要做#include <stdio.h>这个动作, 只是为了让编译器知道函数的原型
保证调用的时候给出的数据类型正确

头文件的使用规范

因此, 在使用和定义函数的时候都应当有头文件!

规范的操作一般是function.c和function.h两个文件成对出现

头文件中一般包含:

• 所有公开的函数的原型
• 所有全局变量的声明

全局变量是可以在多个.c文件中共享的

不对外公开的函数和全局变量

如果希望一个函数只在这一个.c文件中使用
可以字啊函数声明前加上static关键字
那么这个函数只能在当前的编译单元中使用
这样不对外公开的函数一般称为局部函数

局部的全局变量也是同理

注意ta仍旧是全局变量, 只是在这个文件中被使用, 所以叫局部的全局变量

全局变量

声明

和函数一样, 要使得一个项目中所有的.c文件都能访问到公用的全局变量
同样也要做出 声明

变量的声明是为了让程序知道变量的类型
因为只有知道了变量类型, 才能让函数在处理变量前有所准备

声明在头文件中实现, 语法如下
extern int number;

声明和定义

要区别开变量的 声明 和 定义

• 定义: int i = 0;
• 声明: extern int i;

声明的时候不能初始化!
那是定义的时候干的事情

声明这个行为是 不会产生代码 的
能够被声明的东西有很多:

• 函数原型
• 变量声明
• 结构声明
• 宏声明
• 枚举声明
• 类型声明
• inline函数

相对应的, 定义会产生代码
而能被定义的只有:

• 函数定义
• 变量定义

除此以外都不会产生代码

所谓 产生代码, 就是编译器要去编译从而形成可执行的指令
而当编译器看到声明的时候, ta只会去做一个类似于登记的行为
以便在编译实质性代码的时候明确变量等的类型

头文件那些事儿

规则

只有声明可以被写入头文件!!!

上面这条只是规则, 算不上是法律

如果不这么做会造成一个项目中出现多个编译单元中有重名实体的情况
这很可能产生问题

问题

对于结构而言, 其声明不得重复
但是在复杂的程序结构中, 一个头文件被多次引用的情况非常常见, 甚至是难以避免的
下面就是个常见的例子:

头文件"A.h"

typedf struct point{
  int x;
  int y;
} Point;

头文件"B.h"

#include "A.h"
extern int NUMBER;

总程序"main.c"

#include "A.h"
#include "B.h"

int main(){
  /* code here */
  return 0;
}

此时, 依据前文的特性, 编译预处理完成后的实际代码是这样的:

typedf struct point{
  int x;
  int y;
} Point;

typedf struct point{
  int x;
  int y;
} Point;
extern int NUMBER;

int main(){
  /* code here */
  return 0;
}

显然, 结构被重复定义了, 自然少不了报错

标准头文件结构

运用条件编译和宏的配合, 就能保证一个头文件实际只会被include一次
具体语法如下:

#ifndef __A_HEAD__
#define __A_HEAD__

typedf struct point{
  int x;
  int y;
} Point;

#endif

之所以这个宏的左右带上了双下划线
是为了保证不和正常的宏冲突
这也是程序员的约定俗成的习惯

在Visual Studio中, #pragma once也可以起到相同的效果
但是不是所有编译器都支持

• 枚举
  • 引入
  • 概念
  • 语法
  • 说明
  • 套路
  • 枚举量
  • 枚举只是int
  • 小总结
• 结构
  • 声明
  • 注意点
  • 初始化
  • 调用
  • 运算
  • 结构指针
• 结构与函数
  • 结构作为函数的参数和返回值
  • 输入结构
    • 错误示范
• 结构中的结构
  • 结构数组
  • 指针
  • 自定义类型定义
• 联合
  • 语法
  • 特点
  • 用法

枚举

引入

为了消除MagicWord, 我们会将一些字面量定义成常量

例如: const char RED="#ff0000";

但是考虑到会有多个同一方面(例如都是颜色)的常量
我们引入枚举这个概念

概念

枚举是一种用户定义的数据类型
使用关键字 enum (全称: enumeration)

语法

声明一个枚举类型
enum 枚举类型名字 {名字0, 名字1, ... 名字n}

这里的"名字"被称为 枚举量

定义一个这种数据类型的变量
enum 枚举类型名字 变量名 = 名字i

可以把这个枚举类型看作和int一样 在其他输入输出方面, 都和int一致

说明

• 枚举类型名字通常不会真的使用, 重要的是大括号中的名字
• 大括号中的名字相当于常量的变量名
• 这些常量的类型必须是int
• 初始值依次从0到n
• 枚举的实质就是int, ta的意义就是为了方便

套路

由于声明的时候是从0开始赋值的
此时在最后一个名字的后面再加一个名字(一般是numberofxxx)
那么ta的值就是符号的数量
之后在处理循环的时候会很方便

枚举量

声明枚举量的时候可以指定值
没有被指定, 就接着前面的计数 enum COLOR {RED = 3, YELLOW, GREEN=7};
此时YELLOW的值就是4

枚举只是int

如果给枚举类型的变量赋予 不存在/没有意义的值/其他类型 的值
不会报错

小总结

总而言之, 只有当名字在寓意上连贯有意义的情况
也就是比起使用多次const int方便的时候
才会选择使用枚举

结构

要用一个整体表示
一个人的名字, 生日…
时间的年月日…
要使用结构类型

声明

• 形式1:

struct 结构类型{
    int 结构成员1;
    char 结构成员2;
    double 结构成员3;
};
struct 结构类型 结构变量1, 结构变量2;

• 形式2:

struct {
    int 结构成员1;
    char 结构成员2;
    double 结构成员3;
}结构变量1, 结构变量2;

无名类型, 以后用不到

• 形式3:

struct 结构类型{
    int 结构成员1;
    char 结构成员2;
    double 结构成员3;
}结构变量1, 结构变量2;

注意点

• 声明结构类型也是一条语句, 最后的分号不能漏
• 在函数的内部声明结构, 出了函数就用不了, 一般在外部声明
• 声明结构类型 和 声明结构变量 是两个操作, 在上面的形式1就分开了
• 单独声明结构变量的时候不能漏了操作符 struct

初始化

struct 结构类型 结构变量1 = {7, 'Z', 6.4};
struct 结构类型 结构变量2 = {.成员类型1=7, .成员类型3=6.4};

在第二种初始化的形式, 成员类型2没有赋予初始值, 会自动赋0

调用

int a = 结构变量1.结构成员1;

.也是一个运算符, 用来访问结构成员
结构类型是一种类型, 对ta使用.没有意义

运算

对于整个结构变量, 可以做 赋值/取地址/作为参数传递 这些操作

结构变量1 = (struct point){5, 'b', 9.7};
结构变量2 = 结构变量1;

结构指针

和数组有所区别, 结构变量的名字不是地址
必须使用&运算符取地址

结构与函数

结构作为函数的参数和返回值

type function_name(struct struct_name para)
这个函数的参数是一个 结构变量

• 整个结构可以作为参数的值传入函数
• 其实质是, 在函数内新建一个结构变量,
  并复制调用者的结构的值

  函数内发生的不会影响传入的那个结构
  因为函数内部的是新的结构
  注意区别于数组

• 可以返回结构

输入结构

没有直接的方式可以一次scanf一个结构
可以自己写一个函数实现

错误示范

struct point
{
    int x;
    int y;
};

void inputStruct(struct point p);
void outputStruct(struct point p);

int main()
{
    struct point p0 = {0, 0};
    inputStruct(p0);
    outputStruct(p0);
    return 0;
}

void inputStruct(struct point p)
{
    scanf("%d", &p.x);
    scanf("%d", &p.y);
    printf("在inputStruct中:\n");
    printf("x: %d\ny: %d\n", p.x, p.y);
}
void outputStruct(struct point p)
{
    printf("在outputStruct中:\n");
    printf("x: %d\ny: %d\n", p.x, p.y);
}

输入: 12 23 输出结果:

12 23
在inputStruct中:
x: 12
y: 23
在outputStruct中:
x: 0
y: 0

这里main函数中定义的p0并未改变
这是因为, 传入的参数是复制过去的p, 已经不是p0了

结构中的结构

结构数组

struct point points[] = {{x1,x2}, {1,2}, {0,0}};

举例来说
一个矩形可以用左上角和右下角两个点来确定
每个点, 又是由两个坐标组成的
这时候就产生了嵌套的结构, 此时定义一个矩形的方式如下

struct point
{
    int x;
    int y;
};
struct rectangle{
    struct point pt1;
    struct point pt2;
};
struct rectangle r;

这里的矩形 r 有四个值:

• r.pt1.x
• r.pt1.y
• r.pt2.x
• r.pt2.y

指针

仍旧以矩形为例, 此时如果再定义一个矩形指针*rp:
struct rectangle r,*rp;
那么有四个形式是等价的:

• r.pt1.x
• rp->pt1.x
• (r.pt1).x
• (rp->pt1).x

注意, 以下这个形式是错误的:

• rp->pt1->x

因为pt1是结构, 不是指针

自定义类型定义

在定义完一个结构之后, 每次使用都必须在前面加上struct
这给人以一种 “不是亲生” 的感觉…
typedef就允许你"真正"使用自定义的数据类型

typedef用以声明一个已有数据类型的 别名
typedef int Length;
声明后, 两者用法一致

typedef struct ADate{...} Date;
Date d = {...};

在使用结构时, typedef尤其方便 上面的例子中, ADate可以省略不写, 因为最后实际使用的是Date

联合

联合 (union) 在表面上看起来与 结构(struct)是极为相似的

语法

union Test
{
    int i;
    char c;
} union1, union2;

特点

• union的每个成员 都占据同一块空间
• 对其中一个成员赋值, 会覆盖掉其他成员

用法

最常用的场合, 是查看数据在内存中的 储存形式
例如一个联合中有i和char[sizeof(int)]这两个成员
当i中写入一个整数后, 可以通过遍历char数组查看每个字节的值
这有助于我们理解数据内部存储的情况
同时, 在做文件处理时, 也可以用这种方式将数据转化为二进制处理

• 字符串
  • 特殊的0
  • 字符串变量
  • 字符串常量
  • 连接的两个字符字面量
  • 小总结
• 字符串常量
  • 采用数组
  • 指针和数组的选择
• 字符串的有关操作
  • 赋值
  • 输入输出
    • 读取的机制
    • 安全的输入
    • 常见错误
    • 空字符串
• 字符串数组
  • 一些表达方式
  • 程序参数
• 字符函数
  • 单个字符输入 putchar
    • 语法
    • 说明
  • 单个字符输出 getchar
    • 语法
    • 说明
• 字符串函数
  • 所用的库
  • strlen
  • strcmp
  • strcpy
    • 复制一个字符串
    • 可能的实现形式
  • strcat
    • 安全问题
    • 安全的版本
  • strchr
    • 寻找第二个字符
    • 得到第一个配对之前的字符串
  • strstr
• 关于输入输出 和 SHELL的一些知识
  • 什么是SHELL?
  • 为什么敲回车程序才继续?
  • 如何停止输入?

字符串

char word1[]={'H', 'e', 'l', 'l', 'o', '!'};被称为字符数组, 有意义, 但不是一个字符串
在C语言中, 定义字符串是这样的: char word2[]={'H', 'e', 'l', 'l', 'o', '!', '\0'};

注意: word2首先是个字符数组, 但由于其中一个单元存在'\0', 这使之称为了C语言的字符串

特殊的0

1. 整数0和字符'\0'等价
2. 字符'0'对应整数48

char a = '0';
char b = '\0';
printf("a=%d\n", a);
printf("b=%d\n", b);

结果是:

a=48
b=0

3. '\0'标志着字符串的结束, 但ta不属于该字符串
4. 计算字符串长度时, 不包括这个'\0'(当然, 作为数组时的长度, 以及在计算内存占用时, 仍旧会包含在内)

字符串变量

定义的语法有这样3种

char *str = "Hello";
char word[] = "Hello";
char line[10] = "Hello";

注意, 对于word来说, ta占据了6个字节, 最后的结束符'\0'会由编译器自动补上

char word[] = "Hello";
printf("sizeof(word)=%d\n", sizeof(word));

结果是:
sizeof(word)=6

字符串常量

形如"Hello"的带有双引号的字面量被称为 字符串常量 或是 字符串字面量
这样的字面量会被编译器编译为一个字符数组存放在别处

连接的两个字符字面量

如果两个字符串是相邻的, 且中间没有其他符号, 编译器会自动将两者连接起来
比如一下这个例子:

printf("The end is"
        " not the end.\n");

结果是:

The end is not the end.

此外, 还可以在字符串的中间换行断开, 并用反斜杠\承接
但要注意的是, 这样会把制表符一起混进去

int main()
{
    printf("The end is\
            not the end.\n");

    return 0;
}

结果是:

The end is            not the end.

小总结

1. 字符串是一种数组
2. 不能直接参与运算
3. 一般用数组遍历的方式使用字符串
4. 唯一特殊的是可以用字符串字面量直接对字符数组初始化

字符串常量

尝试对一个直接定义的字符串做修改

char *s="Hao";
s[0]='C';

结果是程序崩溃

实际上, 通过查询变量的地址, 不难发现
这些字符串字面量的实际地址很小(相较于其他变量的地址)
其实这个地址指向的是存放原始代码的地方, 收到系统保护, 显然是不允许修改的

这是因为 字符串常量 存储的位置与其他变量不同
其实质是一个只读变量
相当于const char *s

采用数组

char s[]="Hao";
s[0]='C';

这种方法就不会报错了

还是通过查看地址就能发现
此时的地址较大, 说明是一般的变量了

指针和数组的选择

选用数组:

• 表示 “字符串就在这儿”
• 作为本地变量, 空间被自动开辟/回收

选用指针:

• 不知道在哪里, 只是去读取不做修改
• 要动态分配空间的话(使用malloc), 必定需要使用指针

此外, 作为一个函数的参数时, 这两种效果一致

要构造字符串, 选用数组
要处理字符串, 选用指针

字符串的有关操作

赋值

char* s1 = "title";
char* s2;
s2=s1;

根据之前的内容我们可以知道, 第三行的赋值命令的实质, 只是让指针s2也指向了s1指向的字符串的地址
这个过程并不会开辟新的空间, 创造新的字符串

之后在字符串函数中, 有个strcpy函数可以实现创造一个新的一样的字符串的需求

输入输出

char string[8];
scanf("%s", string);
printf("%s", string);

字符串对应的 格式字符 是"%s"

读取的机制

对于scanf, 其实际动作是读取到 空格/换行符/Tab 为止
这个读取到的"单词"是不包含上述的三样的
而且scanf是不安全的, 因为ta不知道读取内容的长度

char word1[8];
char word2[8];
scanf("%s", word1);
scanf("%s", word2);
printf("%s|<=\n", word1);
printf("%s|<=\n", word2);

输入的内容是: hello world[回车]
输出的内容是:

hello|<=
world|<=

安全的输入

可以在格式字符中间加入一个限定, 指定读入的字符个数

char string[8];
scanf("%7s", string);

下一个scanf的读取这后面开始

注意数字应当等于字符串数组的大小减一

scanf非常不安全, 如果纵容ta随意读取的话, 会造成 数据溢出
其后果可能报错, 可能无大碍, 可能崩溃
更严重的是, 通过ta, 攻击者可以注入攻击性代码, 篡改内存, 甚至能实现操纵电脑

常见错误

char *string;
scanf("%s", string);

第一行代码的意义是: 定义一个字符串类型的指针, 但违背初始化, 是个 野指针

这种定义通俗来说就是:"string是一个将来要指向某个字符数组的指针"
未被初始化就意味着ta会指向任何地方, 有可能会指向不该指的地方

空字符串

char a1[100]="";
这行代码初始化了一个空字符串

• 这是正确的操作, a1是合法的字符串
• a1[0]=='\0'是true

char a2[]=""; 如果让电脑自动分配空间, 那么a2的长度就是1
并且唯一的元素a2[0]就是'\0', 没有意义, 无法存放字符串

字符串数组

一些表达方式

• char **a;: a是一个指针, 指向另一个指针, 而那个指针指向一个字符(串)

这样的指针通常称为 二级指针

• char b[][]: 编译无法通过, 因为第二位的大小必须给定
• char c[][10]: 表示若干个大小为10的字符数组, 但是如果用于储存字符串, 那么其长度必须确定有上界
• char *d[]: 每一个元素都是一个字符指针, 能装下很多字符串. 因此, 一般用ta作为字符串数组

程序参数

来看看main函数的参数:
int main (int argc, char const *argv[])

• argc: 表示字符串数组的个数
• *argv[]: 字符串数组, 存有若干指令, 这些指令是在运行程序时一并输入的参数

做一个很简单的试验就能知道*argv[]存了什么

int main(int argc, char const *argv[])
{
    for (int i = 0; i < argc; i++)
    {
        printf("%d: %s\n", i, argv[i]);
    }

    return 0;
}

编译为exe文件后在命令行输入指令: .\test.exe 123 abc \n \t
会发现输出结果为:

0: [文件目录]\test.exe
1: 123
2: abc
3: \n
4: \t

第[0]条的意义是什么?
有时候可以说明是以何种方式来运行程序的(比如这种方式下就得到了文件的目录)

通过这种方式可以在外部给程序传参了

字符函数

单个字符输入 putchar

语法

原型
int putchar(int c);
使用
putchar('a')

说明

• 作用是向 标准输出 写一个字符
• 接受的参数是int类型, 但实际上只能接收一个字符的大小
• 返回值是写了几个字符(通常是1)
• 如果写入失败, 返回EOF (end of file)

EOF是C语言中定义的 “宏”, 其值是-1

单个字符输出 getchar

语法

原型
int getchar(void);
使用
char a = getchar()

说明

• 之所以返回值是int, 是因为有可能要返回EOF

字符串函数

所用的库

常用的标准库是<string.h>
常用的字符串函数有:

• strlen
• strcmp
• strcpy
• strcat
• strchr
• strstr

strlen

原型: size_t strlen(const char *s);
作用: 返回s的字符串的长度(不包括末尾的0)
备注: len 是 length 的缩写

可能的实现形式:

int mylen(const char* s){
    int index = 0;
    while (s[index++]!='\0')
        ;
    return --index;
}

strcmp

原型: int strcmp(const char *s1, const char *s2);
作用: 比较两个字符串是否相等
返回值:

• 0: 表示两者相等
• 大于零: 表示前者大于后者
• 小于零: 表示前者小于后者

这里的大小是说字母的ASCII码值, 字母'a'就比'b'来的小
返回值其实就是: 第一个不相等的位置上的字符的差值

备注: cmp 是 compare 的缩写

可能的实现形式:

• 数组形式

int mycmp(const char *s1, const char *s2)
{
    int i = 0;
    while (s1[i] == s2[i] && s1[i] != '\0')
    {
        i++;
    }
    return s1[i] - s2[i];
}

• 指针形式

int mycmp(const char *s1, const char *s2)
{
    while (*s1 == *s2 && *s1 != '\0')
    {
        s1++;
        s2++;
    }
    return *s1 - *s2;
}

如果直接s1==s2会得到什么?
永远会是false和warning!
因为这个操作实质上是在比较两者的地址, 而地址绝对不是同一个

有一些编译器的strcmp只会返回0或者±1
那这个时候返回值可以改写为三元表达式, 能达到相同效果

strcpy

原型: char* strcpy(char *restrict dst, const char *restrict src);

关键字: restrict表明src和dst不能重叠

“重叠” 就是说dst可能就在src的前方, “拷贝"的动作会覆盖原字符

作用: 把src的字符拷贝到dst
返回值: 就是dst
注意: 参数先dst后src

复制一个字符串

char *dst = (char *)malloc(strlen(src) + 1);
strcpy(dst, src);

一个小套路, 先申请动态分配空间, 确保这里的dst不会涉及其他内存, 是独立的存在
注意: 别漏了+1

可能的实现形式

• 数组

char* mycpy(char *dst, const char *src)
{
    int index = 0;
    while (src[index]!='\0')
    {
        dst[index] = src[index];
        index++;
    }
    dst[index] = '\0';
    return dst;
}

• 指针

char* mycpy(char *dst, const char *src)
{
    char *result = dst;
    while (*dst++=*src++)
        ;
    return result;
}

事实上, 无论代码怎么精简, 编译之后效率是一样的
写的很精简只会令人难以理解(可以看做是一种另类的锻炼方式吧)

strcat

原型: char* strcat(char *restrict s1, const char *restrict s2);
作用: 吧s2拷贝到s1后面, 接成更长的字符串

实质还是一种拷贝
其实就是把s2的第一个字符拷贝到s1最后的\0

返回值: s1

安全问题

strcpy与strcat都存在明显的安全隐患
即, 盲目的写入
这很可能会覆盖掉其他需要的数据

安全的版本

• 对于cpy
  char* strncpy(char *restrict dst, const char *restrict src, size_t n);

• 对于cat
  char* strncat(char *restrict s1, const char *restrict s2, size_t n);

上述两个函数多了一个参数n
n表示 目的地最多能容纳多少字符
如果超出了这个值, 多余的会被掐掉
因此不存在越界问题

• 对于cmp
  int strncmp(const char *s1, const char *s2, size_t n);

这里其实并非是出于"安全"目的而设计这个函数
这个n表示仅仅比较两个字符串的前n位, 其余忽略

strchr

原型:

• char * strchr(const char *s, int c);
• char * strrchr(const char *s, int c);

作用: 在字符串s中寻找字符
后者只是在名字上多了一个’r’, 表示从右边开始找

返回值:
返回那个字符的指针
没有找到返回 null

寻找第二个字符

char str[] = "zhyDaDa";
char *p = strchr(str, 'D');
p = strchr(p + 1, 'D');
printf("%s\n", p);

这里当找到第一个’D’后得到了其指针p,
此时的p可以看做是一个字符串(因为后面有'\0')
从p的后面一个字符找起, 即得到第二个’D'

得到第一个配对之前的字符串

char str[] = "zhyDaDa";
char *p = strchr(str, 'D');
char *t = (char *)malloc(strlen(str) + 1);
char c = *p;
*p = '\0';
strcpy(t, str);
*p = c;
printf("str: %s\n", str);
printf("p: %s\n", p);
printf("t: %s\n", t);
printf("c: %c\n", c);
free(t);

输出的结果是:

str: zhyDaDa
p: DaDa
t: zhy
c: D

这里用了一个非常巧妙的小技巧
即, 将扫描到的第一个匹配改写成'\0'
这样原来的字符串就缩减到了第一个匹配之前的字符串
当然这之后还要改回去, c就是临时储存的被改掉的字符

strstr

原型:

• char * strstr(const caht *s1, const char *s2);
• char * strcasestr(const caht *s1, const char *s2);

作用: 前者在一个字符串中寻找字符串
后者的区别是, 在名称上多了一个"case”
ta在寻找字符串的时候会 忽略大小写

关于输入输出 和 SHELL的一些知识

什么是SHELL?

SHELL就是人机交互的接口
用户敲键盘, 输入的字符, 输入快捷键等等行为, 会先送到SHELL去处理
SHELL会准备一个 缓存区 去接受用户的输入
在那之后SHELL把这个缓存区交给程序去处理
程序再告诉SHELL要显示什么, 藉由SHELL来打印到控制台

通俗来说, SHELL 是连接用户和程序之间的一个中介

为什么敲回车程序才继续?

既然getchar只接收一个字符, 为什么在用户输入了很多内容后仍旧处在"等待输入"的状态, 直到用户键入回车才有反应?

这是因为SHELL最基本的一个功能就是 “行编辑”
在按下回车之前, 他们都没有被送到程序那里去

“行编辑"其实就是在输入前的一个调整, 让你写下来的东西处在编辑状态
否则如果没有这个功能, 你每次按下一个键就会立刻生效, 那么就无法输入大于一个字符的信息了

当用户编辑好要输入的内容后, 按下了回车
回车的动作被SHELL接收, ta就把用户输入的内容(连带着那个回车一起)并入缓存区
接着SHELL把缓存区的内容交给程序, 此时程序才从缓存区读入字符
程序一旦读完了缓存区的内容并且又需要用户输入了
那么程序告诉SHELL, SHELL就让用户输入(这就是等待输入的状态)

比方用户输入的是: abc123并按下回车
那么缓存区的状态就类似于: |a|b|c|1|2|3|\n|\0|

这里的两个|表示一个字符的单位
最后的\0是假想的, 实际中会用其他符号来代替, 用来表示缓存区的结尾

如果此时有形如scanf("%c%c%c%d%d")的输入命令, 缓存内容不够了
用户再输入: ‘789def并按下回车 那么缓存区就类似于: |a|b|c|1|2|3|\n|7|8|9|d|e|f|\n|\0|`

如果上述的读取运行了, 那么缓存区就会变成:
|d|e|f|\n|\0|
注意, 此时的缓存区不是空的!
这就是为什么后面跟着的读取会不再要求用户输入!
例如后面还有getchar

这也就是为什么推荐在要求用户输入内容后
最好跟上一个fflush(stdin)来清空缓存

子函数要求输入后如果有残余的缓存, 那么主函数的输入很可能出问题

如何停止输入?

下面这段代码会不断接受并打印输入的内容
只是通过输入字符是无法跳出循环的

int c;
while ((c = getchar())!=EOF)
{
    putchar(c);
}
printf("读到了EOF, 程序正常结束");

此时就要告诉SHELL, 通过SHELL达成目的

如果键入Control+C, 那么相当于要求SHELL强制结束程序
此时由于程序非正常退出, 最后一行代码就不会输出

如果键入Contorl+Z(不同的SHELL如Linux的, 就是输入Contorl+D)
此时SHELL就会在缓存区的最后添上代表EOF的一个符号
此时 getchar 才读到了 EOF
最后的输出也证实了这一点

• 指针
  • 指针的定义
  • 重要的小细节
  • 作为参数的指针
• 取地址
  • 取地址运算符
  • 无法取地址的情况
  • 有趣试验
    • 相邻的变量
    • 数组的地址
    • 二维数组的地址
• 应用
  • 应用一_交换变量
  • 应用二_多个返回值
  • 应用三_运算状态
  • 常见误区
• 指针与数组
  • 参数表中的数组
  • 数组变量是特殊的指针
• 指针与const
  • 指针是const
  • 所指是const
  • 小练习
  • 转换
  • const数组
  • 保护数组值
• 指针的运算
  • 加一的实质
  • 可能参与的计算
  • 连招
  • 0地址
• 指针的类型
  • 未知类型
  • 指针的类型转换
• 动态内存分配
  • 接收数据
  • 没空间的情况
  • 算算被分配多少空间
  • free的注意事项

指针

指针就是保存地址的变量

指针的定义

int i;
int* p = &i;

上面这段的含义是:

• i的地址交给了p
• p获得的值是i的地址
• p指向了i

这几种说法都正确

重要的小细节

int* p,q;  
int *p,q;

这里的*是附着于p身上的, 与ta靠近的位置无关
注意: 不存在int*这种变量类型!
正确的说法是: *p是一个int 类型的变量, 于是p是一个 指针

作为参数的指针

void f(int *p)
通过传递指针, 函数得到了参数的地址
这使得函数内部拥有了访问外部的能力

所谓 访问 就是可以对变量进行读写

满分解释: 把你家的门牌号扒下来给物管

取地址

取地址运算符

&是取地址运算符, 也是一个运算符
作用是取得变量的地址, 其后必须是一个变量
取得的地址输出时要使用%p
地址的(数据)大小与int是否相同取决于编译器
地址与整数不一定是相同的

无法取地址的情况

int p = (int)(i++); 会报出error
因为, &后面 必须是明确的一个变量

有趣试验

相邻的变量

int main()
{
    int i=0;
    int p = (int)&i;
    printf("%p\n", &i);
    printf("%p\n", &p);
    return 0;
}

输出结果为:

000000000061FE1C
000000000061FE18

在内存中, 先定义的变量在更高的地方
在C语言的内存模型中 本地变量被分配在一个被称为 堆栈(stack) 的地方
堆栈会自上而下分配变量

在这个例子中, 两个 int 是紧挨着定义的
因此相差4

数组的地址

int main()
{
    int a[10]={0};
    
    printf("%p\n", a);
    printf("%p\n", &a);
    printf("%p\n", &a[0]);
    printf("%p\n", &a[1]);

    return 0;
}

结果是:

000000000061FDF0
000000000061FDF0
000000000061FDF0
000000000061FDF4

数组在堆栈中从下而上分配
数组的名字就是一个地址
其与第0个元素的地址一致

二维数组的地址

    int a[10][3];
    
    printf("a: %p\n", a);
    printf("&a: %p\n", &a);
    printf("&a[0]: %p\n", &a[0]);
    printf("&a[1]: %p\n", &a[1]);
    printf("&a[0][0]: %p\n", &a[0][0]);
    printf("&a[1][0]: %p\n", &a[1][0]);
    printf("&a[1][2]: %p\n", &a[1][2]);

其结果:

a: 000000000061FDA0
&a: 000000000061FDA0
&a[0]: 000000000061FDA0
&a[1]: 000000000061FDAC
&a[0][0]: 000000000061FDA0
&a[1][0]: 000000000061FDAC
&a[1][2]: 000000000061FDB4

为了让结果更具可读性, 稍微改了一下

    int a[10][3];

    printf("a: %d\n", (int)(a) - (int)a);
    printf("&a: %d\n", (int)(&a) - (int)a);
    printf("&a[0]: %d\n", (int)(&a[0]) - (int)a);
    printf("&a[1]: %d\n", (int)(&a[1]) - (int)a);
    printf("a[0]: %d\n", (int)(a[0]) - (int)a);
    printf("a[1]: %d\n", (int)(a[1]) - (int)a);
    printf("&a[0][0]: %d\n", (int)(&a[0][0]) - (int)a);
    printf("&a[0][1]: %d\n", (int)(&a[0][1]) - (int)a);
    printf("&a[0][2]: %d\n", (int)(&a[0][2]) - (int)a);
    printf("&a[1][0]: %d\n", (int)(&a[1][0]) - (int)a);
    printf("&a[1][1]: %d\n", (int)(&a[1][1]) - (int)a);
    printf("&a[1][2]: %d\n", (int)(&a[1][2]) - (int)a);

结果是:

a: 0
&a: 0
&a[0]: 0
&a[1]: 12
a[0]: 0
a[1]: 12
&a[0][0]: 0
&a[0][1]: 4
&a[0][2]: 8
&a[1][0]: 12
&a[1][1]: 16
&a[1][2]: 20

总结得出:

• 数组名称对应着a[0][0]的地址
• 往后的所有元素都越来越大(在堆栈中向上堆叠)
• 每一行的最后一个元素与下一行的第一个元素紧挨着

应用

应用一_交换变量

void swap(int *pa, int *pb);

int main()
{
    int a = 4, b = 6;
    swap(&a, &b);
    printf("a=%d, b=%d\n", a, b);

    return 0;
}

void swap(int *pa, int *pb)
{
    int t = *pa;
    *pa = *pb;
    *pb = t;
}

遇到swap这种对外部参数的值操作的函数, 只能使用指针

应用二_多个返回值

传入的参数实际上是一些容器
函数实际上在将多个返回值装入这个容器
这一过程必定需要使用指针

void MinMax(int a[], int len, int *min, int *max);

int main()
{
    int a[] = {10, 99, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    int min,max;
    MinMax(a, sizeof(a) / sizeof(a[0]), &min, &max);
    printf("min=%d; max=%d\n", min, max);

    return 0;
}

void MinMax(int a[], int len, int *min, int *max){
    *min = *max = a[0];
    for (int i = 0; i < len; i++)
    {
        if(a[i]<*min){
            *min = a[i];
        }
        if(a[i]>*max){
            *max = a[i];
        }
    }    
}

在这一类场景中, min和max虽然是main函数传入的参数
但他们的实际作用, 是把返回值带出来

应用三_运算状态

函数操作会有成功与否, 一般(如scanf)会返回0表示成功, -1表示失败
如果函数运算的结果也可能是0或-1那么就无法判断函数是否成功执行
因此, 需要分开返回 运算状态 和 运算的实际结果
一般来说, 函数的返回值是运算状态, 用另一个指针参数带出实际结果

int divide(int a, int b, int *c);

int main()
{
    int a = 5, b = 2, c;
    if (divide(a, b, &c))
    {
        printf("%d/%d=%d\n", a, b, c);
    }
    return 0;
}

int divide(int a, int b, int *c)
{
    int ret = 1;
    if (b == 0)
    {
        ret = 0;
    }
    else
    {
        *c = a / b;
    }
    return ret;
}

常见误区

int *p=12;
这条语句拆开来看是这样的:

int *p;
*p = 12;

注意: 这类指针俗称 “野生指针”
因为指针没有明确的指向
此时p可能指向内存中的任意位置
此时如果正好指向不可写入的一块区域
那么程序立刻崩溃

指针与数组

参数表中的数组

在函数的参数表中, 传入的数组实质上是指针
以上文应用二_多个返回值中的函数来分析
void MinMax(int a[], int len, int *min, int *max)
这里可以改写成:
void MinMax(int *a, int len, int *min, int *max)
对于这种数组指针, 仍旧可以使用数组运算符[]来参与运算

一定注意, 所谓

*a与a[]等价

这只是在函数原型的参数表中的说法

数组变量是特殊的指针

• 数组变量本身表达地址, 无需对其取地址
  int a[10]; int *p=a;
• 但是, 对于数组的单个元素, 都表达确切的变量, 需要用&取地址
  a==&a[0]
• []运算符亦可以对指针使用 p[0]与a[0]完全等价
• *运算符显然也可以对数组使用
  *(a+2) = 25

p[2]的含义是: 将p视作数组的第一个元素的地址, 取其第3个单元
int a[] 同 int * const a=... 等价
这里的const是常量的意思, 即数组变量这种特殊的指针一旦被定义就无法再改变其指向的对象了

指针与const

const 是说值不能被修改
指针本身有可能是 const , 指针所指的变量也可能是 const

指针是const

这意味着该指针一旦得到某个变量的地址, 不能再指向其他变量
注意: 指针所指向的值仍旧可以修改, 因为值不是 const

int i = 0;
int * const q = &i;
*q = 26; //OK
q++;     //ERROR

所指是const

const int *p = &i;
这行代码意味着:

• i可以做修改
• p可以做修改
• 唯独不可以通过*p去修改i

小练习

int i;
const int* p1 = &i;
int const* p2 = &i;
int *const p3 = &i;

答案是:

• p1: 所指是const
• p2: 所指是const
• p3: 指针是const

判断的技巧: const 和 * 的位置
const在前就是所指不能修改
const在后就是指针不能修改

转换

总是可以将非 const 的值转化为 const
void f(const int* x);
可以照常将一个普通的地址传入, f函数将向你保证:
在f中, 不会对这个地址对应的值做修改

事实上, 这是一个常用的套路
由于传递的值会很大, 自然会用传地址来代替(数组就是这个想法)
为了避免函数修改数值, 就用const来做保证

const数组

const int a[]={1,2,3,4,5,6};
数组变量在声明时就是一个const指针
如果再加上const, 就表明数组中每个单元全都是const
所以, 初始化时 必须赋值

保护数组值

为了避免函数修改数组内的值, 可以在函数声明中设置参数const

指针的运算

加一的实质

int *p1;
char *p2;

打印他们和+1之后的16进制值, 比较其差值:

• p1+1比p1数值上差4
• p2+1比p2数值上差1

对于指针来说, +1的实际含义是 指向下一个单元
因此, 从数值上来看, 实际给指针加上的 是数据类型的size大小

如果+1是字面上的含义, 那么指针移动到代表一个int的四个字节的中间
这样做也是没有任何意义的
同样, 如果指针指向的不是一片连续分配的空间(如数组),那么这种运算也没有意义

可能参与的计算

• 加减法
• 加加和减减
• 两个指针相减
• 两个指针比较

这里还需注意: 指针相减的意义是两个指针间有几个单元
因此, 对于int指针, 数值上相差24, 但结果是6

数组中, 单元的地址必定是 线性递增的

连招

*p++
用意是:

• 取出*p, 即指针指向的内容
• 顺便指针向后移动

*的优先级没有++高

有些CPU上, 这个连招会被直接翻译成一条指令 (跑得更快)

0地址

每个程序跑起来的时候, 系统都会赋予ta一块 “虚拟的” 内存空间
因此, 每个程序都有所谓的 0地址

但这个地址不能碰, 不仅不能更改, 有时还不允许读取
操作ta可能会导致程序崩溃
因此, 0地址被赋予了特殊含义:

• 指向0的指针可以看做是无效的指针(函数返回这样的指针就可能意味着操作不能执行)
• 给指针初始化的时候可以先初始化为0, 表示ta还尚未被使用

有个特殊的字面量叫NULL, 就表示0地址
部分编译器仅支持NULL, 所以最好使用ta来表示0地址

指针的类型

指针的类型和其指向的数据类型一致
无论什么类型的指针, 他们都是存放地址的, 因此所有指针大小一致
考虑到上文分析的指针运算的意义, 不同类型的指针之间不可以赋值(主要为了避免用错指针)

未知类型

void * 这样的类型表示指向的变量类型未知(或者说不用关心)
其在计算方式上和char * 相同
但要注意, 这两个类型的指针仍旧不相通

指针的类型转换

int *p = &i;
void *q = (void *)p;

指针可以转换类型
这种转换并不改变其指向的变量的类型(这个例子里i仍旧是int)
这么做仅仅改变了我们透过p看待i的眼光

动态内存分配

接收数据

数据接收前需要知道数据的个数, 这是为了在内存中开辟相应的空间

在C99之前, 需要手动开辟空间
int *a=(int*)malloc(n*sizeof(int));

这里malloc会返回void *
意思就是开辟了一块空的没有意义的空间, 然后把地址告诉你

而且在程序的最后, 还要加上一句
free(a)
表示把用好的空间还回去

没空间的情况

申请空间(malloc)失败会得到返回值NULL

算算被分配多少空间

#include <stdio.h>
#include <stdlib.h>

int main()
{
    void *p;
    int count = 0;
    while ((p = malloc(100 * 1024 * 1024)))
    {
        count++;
    }
    printf("被分配了%d00MB的空间", count);

    return 0;
}

在笔者的电脑上的结果是:
被分配了43500MB的空间

free的注意事项

void *p;
int count = 0;
(p = malloc(100 * 1024 * 1024));
p = &count;
free(p);

上述代码运行结果就是程序崩溃
一下情况会崩溃:

• 借了不还
• 还回去的不是借来的地址
  • 例如p+1
  • 例如(p=&count)
• free 了之后再 free

对于小程序, 程序结束之后会直接释放所有内存
但对于服务器/大程序, 长时间 申请不free 会导致内存逐渐下降, 这会造成严重的后果
注意: 唯独free(NULL)不会报错

很可能是为了让我们养成 对指针初始化就用NULL的习惯

• 定义数组
  • 语法
  • 本质和特征
  • 数组的特点
  • 数组的单元、下标
  • 有效的下标范围
• 数组的集成初始化
  • 定义
  • 写法注意
  • 集成初始化时的定位
• 数组操作
  • 数组长度
  • 数组赋值
• 数组的应用
  • 搜索
  • 素数判断
• 二维数组
  • 内存中的排布
  • 遍历
  • 初始化

定义数组

语法

语法: <类型> 变量名称[元素数量]

• 类型是指数组中每个元素的类型
• 元素数量必须是整数
• 元素数量应当在编译时就是确定的字面量, 在C99之后可以是变量

本质和特征

数组的本质是一个容器 (放东西的东西)

就现代编程语言而言, 评判其能力大小的一项标准, 就是该语言提供容器的能力

数组的特点

• 所有元素都具有相同的数据类型
• 数组的大小一旦创建就不得改变
• 在内存中, 数组中的元素是紧密、连续、依次排列的

数组的单元、下标

数组的每个单元就是数组类型的一个变量
使用数组时放在[]中的数字称为 下标 or 索引
下标是从0开始计数的

虽然数组并不是C语言发明的, 但下标从0开始计数是从C语言开始的
重要的原因是, C语言的编译器可以简化很多

有效的下标范围

编译器和运行环境不会检查数组的下标是否越界(无论读写)
可能会造成报错/警告: segmentation fault

int a[0]
长度为0的数组可以存在, 但毫无用处, 因为不存在有效的下标范围

数组的集成初始化

定义

int a[] = {1,22,333}这种写法被称为 数组的集成初始化

• 直接用大括号给出数组中所有元素的初始值
• 不需要给出数组的大小, 编译器会自动计数

写法注意

注意: 如果是这种写法
int a[5]={2,3};
其效果等同于
int a[]={2,3,0,0,0};

集成初始化时的定位

在C99中, 允许用[n]在初始化数据中给出定位
没有定位的数据接在前面的位置后面
其他位置填补零
如果不给出数组大小, 编译器会把涉及到的最大的位置定为数组的长度
这种写法特变适合初始数据稀疏的数组

int a[8] = {
  [0]=2, [2]=3, 6,
};

上面的写法等同于
int a[8] = {2,0,3,6,0,0,0,0};

int a[] = {[3] = 1, 2, 3, [5] = 6, 7, 8};
等同于 ```int a[] = {0, 0, 0, 1, 2, 6, 7, 8};

数组操作

数组长度

int a[]={1,2,3,};
int length_a = sizeof(a)/sizeof(a[0]); 

这个小技巧对于所有数组都成立

有趣的是在定义数组时, 最后多出来的那个,
这是为了后来人不用再打上逗号而准备的, 对程序来说毫无影响
这么做可以显得自己读过70/80年代的编程书

数组赋值

int a[]={1,2,3,};
int b[]=a;

这么做无法将数组a赋值给数组b
唯一方法是遍历数组

数组的应用

搜索

在一个数组中找出要找的数字

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int search(int key, int a[], int length);

int main()
{
    int a[] = {2, 4, 6, 82, 455, 1, 10, 54, 4, 3, 5, 17, 14, 32, 8};
    int x;
    int loc;
    printf("请输入一个数字: ");
    scanf("%d", &x);
    loc = search(x, a, sizeof(a) / sizeof(a[0]));
    if (loc != -1)
    {
        printf("%d在第%d个位置上\n", x, loc);
    }
    else
    {
        printf("%d不存在\n", x);
    }

    return 0;
}

int search(int key, int a[], int length)
{
    int ret = -1;
    for (int i = 0; i < length; i++)
    {
        if (a[i] == key)
        {
            ret = i;
            break;
        }
    }
    return ret;
}

这里注意: 数组作为函数的参数时, 往往要求用另一个参数来传入数组的大小
这是因为当数组作为参数时:

• 不能再利用sizeof来计算数组的元素个数
• 也就无法计算数组的大小

素数判断

如果使用素数去判断数字是否是素数, 时间复杂度最低
但仅仅在构造素数表的时候有用

以下代码用于找出前100个素数

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int isPrime(int x, int knownPrimes[], int length);

int main()
{
    const int number = 100;
    int prime[number];
    prime[0] = 2;
    int count = 1;
    int i = 3;
    while (count < number)
    {
        if (isPrime(i, prime, count))
        {
            prime[count++] = i;
        }
        i++;
    }

    for (i = 0; i < number; i++)
    {
        printf("%d", prime[i]);
        if ((i + 1) % 5)
            printf("\t");
        else
            printf("\n");
    }

    return 0;
}

int isPrime(int x, int knownPrimes[], int length)
{
    int ret = 1;
    for (int i = 0; i < length; i++)
    {
        if (x % knownPrimes[i] == 0)
        {
            ret = 0;
            break;
        }
    }
    return ret;
}

如果说想构造n以内的素数表, 可以采用挖空法
即, 挖掉所有倍数
以下求出25以内的素数

int main()
{
    const int number = 25;
    int isPrime[number];
    for (int i = 0; i < number; i++)
    {
        isPrime[i] = 1;
    }

    for (int x = 2; x < number; x++)
    {
        if (isPrime[x])
        {
            for (int i = 2; i * x < number; i++)
            {
                isPrime[i * x] = 0;
            }
        }
    }
    for (int i = 2; i < number; i++)
    {
        if (isPrime[i])
        {
            printf("%d\t", i);
        }
    }
    printf("\n");

    return 0;
}

要多多考虑时间复杂度, 有时候不能被人的思维所局限

二维数组

int a[3][5]通常被理解为一个3行5列的矩阵

内存中的排布

遍历

for (i = 0; i < 3; i++)
{
    for (j = 0; j < 3; j++)
    {
        a[i][j] = i * j;
    }
}

平时数学上的 $a[i,j]$ 表示坐标系中的一个点
但在C语言中, 由于,是一个运算符
a[i,j]和a[j]是等价的, 这显然不是正确的表达二维数组的方式

初始化

int a[][5] = {
    {0, 1, 2, 3, 4},
    {2, 3, 4, 5, 6},
};

列数必须给出, 行数可以省略
其他一些细节和一位数组一致

其实可以用一长串数字初始化
因为这与内存中的结构实质上一致
为了人类读者阅读方便, 还是用{}来写较好

• 引入
• 定义与使用
  • 什么是函数?
  • 函数的定义
  • 函数的调用
  • 函数的返回
• 函数的原型
  • 函数定义与调用先后关系的讲究
  • 函数的原型与声明
• 参数传递
  • 类型不匹配
  • 传参
• 本地变量
  • 变量的生存期和作用域
  • 本地变量的规则
• 补充
  • 定义无参数的函数
  • 逗号运算符
  • 函数里的函数
  • 奇形怪状
  • 关于main函数

引入

求 0-10 和 20-30 和 35-45 的和

#include <stdio.h>
void main()
{
    int i, sum;
    for (sum = 0, i = 1; i <= 10; i++)
    {
        sum += i;
    }
    printf("%d到%d的和是%d\n", 1, 10, sum);

    for (sum = 0, i = 20; i <= 30; i++)
    {
        sum += i;
    }
    printf("%d到%d的和是%d\n", 20, 30, sum);

    for (sum = 0, i = 35; i <= 45; i++)
    {
        sum += i;
    }
    printf("%d到%d的和是%d\n", 35, 45, sum);
}

代码复制是程序质量不良的表现!

这是因为以后做代码维护的时候要修改很多处

#include <stdio.h>
void sum(int begin, int end){
    int i;
    int sum = 0;
    for (i = begin; i <= end; i++)
    {
        sum += i;
    }
    printf("%d到%d的和是%d\n", begin, end, sum);
}

void main()
{
    sum(1, 10);
    sum(20, 30);
    sum(35, 45);
}

将重复部分提取出来, 方便以后的调用

定义与使用

什么是函数?

函数是一块代码, 接收零个或多个值, 做一件事情, 并返回零个或一个值

函数的定义

void sum(int begin, int end){
    int i;
    int sum = 0;
    for (i = begin; i <= end; i++)
    {
        sum += i;
    }
    printf("%d到%d的和是%d\n", begin, end, sum);
}

void 是返回类型
sum 是函数名
int begin, int end 是参数表
花括号内的代码块 称为函数体

函数的调用

函数名(参数值)

注意: ()起到了重要的作用

• ()表示前面的表达式是一个函数并且在调用ta, 而不是一个函数指针
• 即便没有参数也要()
• 有参数的话, 需要给出正确的 数量和顺序
• 这些值会按照顺序给函数参数表中的参数(相当于变量)初始化赋值

函数的返回

函数知道每一次是哪里调用了ta, 会返回到正确的地方

函数的原型

函数定义与调用先后关系的讲究

要在调用函数的上面定义函数, 原因如下:

• C的编译器以自上而下的顺序分析代码
• 在遇到调用的函数的时候, ta需要知道其定义
• 即, 参数的 个数/类型/顺序
• 这样才能检查调用是否正确

如果定义语句放在调用之下(且不做声明), 其结果要视编译器而定

比如, 如下的代码会发出警告, 在某些严格的编译器上甚至会出现编译失败

#include <stdio.h>
void main()
{
    sum(1, 10);
    sum(20, 30);
    sum(35, 45);
}

void sum(int begin, int end)
{
    int i;
    int sum = 0;
    for (i = begin; i <= end; i++)
    {
        sum += i;
    }
    printf("%d到%d的和是%d\n", begin, end, sum);
}

原因: 当编译器读到调用位置时, 会做出猜测, ta猜测sum函数的声明是如下的样子

int sum (int, int)

但当ta读到sum的定义时发现与之不符, 于是报出了类型冲突的警告
不过有些高级编译器能自行纠正, 仍旧能正确运行代码

联系上述分析, 如果做出如下修改就可以正确运行

#include <stdio.h>
void main()
{
    sum(1, 10);
    sum(20, 30);
    sum(35, 45);
}

int sum(int begin, int end)
{
    int i;
    int sum = 0;
    for (i = begin; i <= end; i++)
    {
        sum += i;
    }
    printf("%d到%d的和是%d\n", begin, end, sum);
    return sum;
}

不过, 编译器仍旧会报出形如 “这个声明是我自己猜的哈” 这样的warning

函数的原型与声明

函数的原型用于告诉编译器一个函数的长相, 包括:

• 名称
• 参数(数量以及类型)
• 返回类型

函数的声明就是展示函数原型的语句
通俗来讲, 声明就是告诉编译器 “你不用猜了”

#include <stdio.h>
void sum(int begin, int end);

void main()
{
    sum(1, 10);
    sum(20, 30);
    sum(35, 45);
}

void sum(int begin, int end)
{
    int i;
    int sum = 0;
    for (i = begin; i <= end; i++)
    {
        sum += i;
    }
    printf("%d到%d的和是%d\n", begin, end, sum);
}

注意:

• 函数在声明之后, 遇到定义时, 会再次检验两者是否一致
• 现在的编程习惯是将函数的原型声明写在调用位置函数的外面
• 原型中可以不用写函数的名称(即便与定义不一样也不会warning), 但一般仍旧会写上(这对于人类阅读者是有意义的)

参数传递

可以传递给函数的值是表达式的结果, 这就包括了:

• 字面量
• 变量
• 函数的返回值
• 计算的结果

类型不匹配

调用函数时给的值与参数类型不匹配是C语言传统上最大的漏洞
编译器会自作主张地帮你转换类型, 但总会不尽如人意

传参

C语言在调用函数的时候, 永远只能传值给函数
注意: 每个函数都有自己的变量空间
参数也位于这个独立的空间中, 和其他函数没有关系
习惯上, 参数表中的参数称作 “形参” , 调用函数时传入的是 “实参”
但容易产生误解, 误认为把参数传给了函数
因此, 推荐称他们 “参数” 和 “值”

本地变量

函数的每次运行, 就会产生一个独立的 变量空间
在这个空间中的变量是只有这次运行独有的, 称作 本地变量(也可以成为局部变量/自动变量)

之所以有局部和本地的区别是因为英文都是local
之所以叫自动变量, 是因为ta的生存期是自动的

注意:

• 定义在函数内部的变量就是本地变量
• 参数也是本地变量

变量的生存期和作用域

生存期 变量开始出现到消亡
作用域 在(代码的)什么范围内可以访问这个变量(即可以其作用)
块 即一对大括号内的范围

#include <stdio.h>
void swap(int x, int y)
{
    int t = x;
    x = y;
    y = t;
}
void main()
{
    int a = 5, b = 6;
    swap(a, b);
    printf("a=%d, b=%d\n", a, b);
}

上述函数的结果是: a=5, b=6

当进入swap函数的时候:

a和b仍旧存在, 即在生存期内
但a和b不在作用域内, 无法在当前上下文去访问他们

作为生存来说, 他们还在
作为作用来说, 他们不在当前作用域内

当返回main函数的时候:

t和x和y都不存在了
因为swap函数的运行已经结束了

本地变量的规则

1. 本地变量是定义在块内的

• 既可以定义在函数的块内
• 也可以定义在语句的块内

语句可以是for和if之类
也可以随意拉一对大括号!

2. 程序运行进入这个块之前, 其中的变量不存在
   离开这个块, 其中的变量就消失了
3. 块外面定义的变量在里面仍旧有效
4. 块里面定义了和外面同名的变量, 则以块内的为准(会掩盖外侧的)
5. 不能在一个块内定义同名的变量
6. 本地变量不会被默认初始化
7. 参数在进入函数的时候就被初始化了(一定要给函数参数要求的值 以初始化)

补充

定义无参数的函数

如果写做void f(void)没有任何问题
在传统C中, 如果写做void f(), 编译器会认为传参不确定, 而非不传参

好心的编译器又会帮你猜想, 然后把事情搞糟
当然最糟糕的是, 不报错

总之, 写void f(void)不会有错

关于int main()的事儿, 很复杂, 在下面讨论

逗号运算符

之前有提到, 逗号,也是一种运算符, 那和调用函数时用到的,如何区分?

• 调用函数时, 圆括号中的逗号,是标点符号
• 在独立的圆括号内, 表示一个运算式, 此时逗号,是运算符

两个参数: f(a,b)
一个参数: f((a,b))

函数里的函数

C语言不允许函数嵌套定义
可以在函数里放函数的声明, 但不能放ta的BODY

奇形怪状

int i, j, sum(int a, int b);
这里定义的sum 函数返回为 int
不算错, 当然不推荐
return (i)
返回 i 值而已
但会误使人认为return是一个函数, 因此也不推荐

关于main函数

• 首先, int main()也是一个函数, ta被称为程序的入口
• 写成int main(void)不会有错
• return 的值是有意义的!!!

在Windows中, 用bat执行这一C语言程序, 会得到return的值
如果用if errorlevel 1...就可以了解错误原因

一般来说, 返回0表示函数正常的运行了
其他非零返回值用来表明错误原因

• 基础数据类型
  • 不同之处:
  • sizeof
• 整数类型
  • 整数的内部表达
    • 负数的表达
    • 二进制负数
    • 补码
  • 数的范围
    • 关键字 unsigned
    • 整数越界
  • 整数的格式化
    • 整数的输入输出
    • 8进制和16进制
  • 选择整数类型
• 浮点类型
  • 浮点的输入输出
    • 科学计数法
    • 输出精度
  • 浮点的范围和精度
    • 超过范围的浮点数
    • 浮点运算的精度
  • 浮点数的内部表达
  • 选择浮点数类型
• 逻辑类型
  • 逻辑运算
    • 优先级
    • 短路
    • 条件运算符
    • 逗号运算
• 类型转换
  • 自动类型转换
  • 强制类型转换

C是有类型的语言, 对于其变量, 必须:

• 在使用前定义
• 确定类型

早期语言 以及 面向底层的语言 更强调类型

• 强类型: 有助于发现简单错误
• 弱类型: 看重事务逻辑

C语言需要类型, 但是对类型的安全检查并不足够

基础数据类型

大致分为四个大类(逻辑和整数看做一类)

前四种被称为 C语言的基础类型 (即本身就有的)

不同之处:

• 名称: int long double
• 输入输出时的格式化: %d %ld %lf
• 表达的范围: char<short<int<float<double
• 内存中占据的大小: 1~16字节
• 内存中的表现形式: 整形是二进制(补码) 浮点数是编码形式(不能直接计算)

sizeof

sizeof是一个运算符, 给出某个类型或者变量在内存中占据的 字节数

• sizeof(int)
• sizeof(i)

注意: sizeof是静态的, ta的括号内不会产生实际运算, 其结果在编译时已经确定下来

#include <stdio.h>
int main()
{
    int a = 6;
    printf("sizeof(a)=%ld\n", sizeof(a));
    printf("sizeof(a+1.0)=%ld\n", sizeof(a + 1.0));
    printf("a=%d", a);
    return 0;
}

其输出结果如下

sizeof(a)=4
sizeof(a+1.0)=8
a=6

整数类型

大小比较

1Byte = 8bit

上图中 字长 是说在寄存器和总线中, 一份数据的大小

整数的内部表达

计算机内部一切都是二进制

• 18 –> 00010010
• 0 –> 00000000
• -18 –> ?

一切数据类型的意义在于我们怎么看待ta

负数的表达

计算机在处理负数时, 会把-视作为一种运算特殊处理, 并不看做负数

二进制负数

有三种方案:

• 仿照十进制, 取一个特殊标记表示负数
• 取中间数为0, 如10000000为0, 比ta小就是负数
• 补码

第一种方案在计算时不能按照常规二进制计算, 要求特殊处理, 太复杂
二方案每次在获取数据的时候总要减去10000000, 也很复杂

补码

考虑-1, 希望能实现-1 + 1 = 0

• 0 –>00000000
• 1 –>00000001
• -1–>11111111

这里-1 + 1的结果实际上是1 00000000
但由于表示数字的字节仅仅8bit, 所以多出来的那位被舍去, 成了0

11111111被当做纯二进制看待时, 是255
但被当做补码看待时, 是-1

同理, 对于-a, 补码就是0-a
实际上是 $2^n-a$, 其中n是这种类型的位数

补码的意义就是拿补码和原码可以加出一个溢出的零
回到之前的三种方案, 补码的优势在于不用变化符号, 直接做加法就可以得出结果

数的范围

对于一个字节(8位 即一个char), 可以表达的是:

• 00000000-11111111

其中:

注意: 这里所说的"整数角度"是针对char来说的
不同类型有不同的角度, 下面就是个例子

#include <stdio.h>
int main()
{
    char c = 255;
    int i = 255;
    printf("c=%d; i=%d", c, i);
    return 0;
}

其结果为:

c=-1; i=255

分析如下:

• 对于char来说,
  • 大小是 8bit
  • 在内存中表现为 11111111
  • 解读为补码(因为首位为1)
  • 输出为-1
• 对于int来说,
  • 大小是 4Byte
  • 在内存中表现为 00000000 00000000 00000000 11111111
  • 解读为正整数
  • 输出为255

关键字 unsigned

在定义变量的时候在类型前面添上 关键字unsigned

#include <stdio.h>
int main()
{
    unsigned char c = 255;
    printf("c=%d", c);
    return 0;
}

运行结果:
c=255

如果一个字面量常数要想表达自己是unsigned, 在其后面加上u或U

• 例如 255U

unsigned的含义是说: 该数被视作一个正数, 不会被视作补码 其副作用就是将一个整数能表示的正数部分扩大两倍
但同样地, ta就无法表示负数

但是, unsigned关键字设计的初衷并不是为了扩大正数部分
而是为了做纯二进制计算, 主要是为了移位

整数越界

如果不断的做+1运算, 到了范围的边界时
考虑到之前的理论, 正整数将"绕一圈"变为负数
用程序来说明:

#include <stdio.h>
int main()
{
    char c = 128;
    c = c + 1;
    printf("c+1=%d\n", c);
    unsigned char u = 0;
    u = u - 1;
    printf("u-1=%d", u);
    return 0;
}

其结果是:

c+1=-127
u-1=255

整数的格式化

整数的输入输出

只有两种形式: int 或 long long

可以通过以下代码理解 “数据类型重在如何看待ta”

#include <stdio.h>
int main()
{
    char c = -1;
    int i = -1;
    printf("c=%u, i=%u\n", c, i);
    return 0;
}

其结果为:

c=4294967295, i=4294967295

printf在接收数据时, 会把
小于等于int大小的整数类型转化为int传入
大于int大小的整数类型转化为long传入

在计算机内存的数据是同样的, 但以不同的方式看待就会有不同的结果
这和计算机内部数据是什么无关, 而取决于是否以正确的方式来使用数据, 使之成为人能读懂的表示

8进制和16进制

字面量整数前加0表示 八进制
加0x表示 十六进制

#include <stdio.h>
int main()
{
    char c = 012;
    int i = 0x12;
    printf("c=%d, i=%d\n", c, i);
    return 0;
}

其结果为:

c=10, i=18

同样的, 这里的进制只是我们的视角
编译器仍旧会换算为二进制

进制只是表示如何把数字表达为字符串
这与内部如何表达数字无关

要想输入输出:

• 八进制的格式为 %o
• 十六进制的格式为 %x

注意: 在十六进制中,
%x会输出带有小写字母的十六进制数字
%X会输出带有大写字母的十六进制数字

16进制很适合表达2进制数据
因为4位二进制刚好是一个16进制位
而8进制的一位数字正好表达3位二进制

因此早期计算机的字长是12的倍数, 而非8

选择整数类型

为什么那么多类型?

• 为了直接和硬件打交道(16位的类型控制芯片上的16个引脚)
• 早期语言的风格

建议: 没有特殊需要, 就选int

• 如今计算机CPU的字长普遍是32/64bit, 一次内存的读写正好是一个int的大小, 一次计算也是一个int
• 选择更短的类型不会更快, 甚至可能更慢
• 考虑到现代编译器一般会设计 内存对齐, 所以更短的类型在内存中可能实际占据的也是一个int的大小
  (即便 sizeof 告诉你更小)

unsigned与否只影响输出的结果, 内部计算是一样的

浮点类型

浮点的输入输出

其中%e是用科学计数法输出

#include <stdio.h>
int main()
{
    double ff = 1234.56789;
    printf("%e, %f, %E", ff, ff, ff);
    return 0;
}

其输出结果为:

1.234568e+003, 1234.567890, 1.234568E+003

科学计数法

以 -5.67E+16 为例子

• 最前面可选的+或-符号
• 小数点.也是可选的
• 可以用e或E
• 符号可以是+或-也可以省略(表示+)
• 整个词不能有空格

输出精度

在%和f之间加上.n可以指定输出小数点后的n位(做四舍五入)

#include <stdio.h>
int main()
{
    printf("%.3f\n", -0.0049);
    printf("%.30f\n", -0.0049);
    printf("%.3f\n", -0.00049);
    return 0;
}

其结果为:

-0.005
-0.004899999999999999800000000000
-0.000

浮点的范围和精度

超过范围的浮点数

• inf表示无穷大(即超出范围的浮点数)
• nan表示不存在的浮点数

#include <stdio.h>
int main()
{
    printf("%f\n", 12.0 / 0.0);
    printf("%f\n", -12.0 / 0.0);
    printf("%f\n", 0.0 / 0.0);
    return 0;
}

其输出结果为:

inf
-inf
nan

也可以是:

1.#INF00
-1.#INF00
-1.#IND00

考虑到现在讨论的范畴是浮点数
如果用整数输出12/0会发生编译错误
这是因为nan/±inf为浮点数独有

浮点运算的精度

注意: 浮点运算是没有精度的

#include <stdio.h>
void main()
{
    float a, b, c;
    a = 1.345f;
    b = 1.123f;
    c = a + b;
    if (c == 2.468)
        printf("相等\n");
    else
        printf("不相等! c=%.10f, 或%f\n", c, c);
}

其输出结果为:

不相等! c=2.4679999352, 或2.468000

输出的结果中, 前者才是c真正的数值, 后者已经由于浮点数的7位有效数字做了四舍五入处理

注意:

• 带小数点的字面量是double 而非 float
• float 需要用f或F后缀来表明身份
• 在浮点计算中, f1==f2这类的关系判断可能失败
• 如果迫不得已, 可以通过fabs(f1-f2)<1e-12来代替
• 其实一般1e-10就可以了
• 不能用浮点数来计算金额, 因为其误差会累积起来
• 只能在一定的范围内相信浮点数的计算结果, 其误差很大

浮点数的内部表达

浮点数在内存中以编码形式储存

• 1bit 用与判断正负号
• 11bit 用于记录指数部分
• 52bit 用于记录分数部分

事实上实际用不了这么多位

浮点数在计算时是由专门的硬件部件实现的
计算 double和float要用的硬件部件是一样的

选择浮点数类型

如果没有特殊需要, 只使用 double

现代CPU能够直接对double做硬件运算
计算速度和存储速度都不比float慢

逻辑类型

C语言原先是没有布尔类型的, 用0和非0就可以判断
后来引入了布尔类型, 由于其不是原生类型, 因此使用前要先加上#include <stdbool.h>
之后才能使用bool和true/false
但事实上, 在输入输出时, 布尔类型仍旧当做整数使用, 无法输出为true/false

逻辑运算

数学中的4<x<6在程序中, 应当表示为x>4&&x<6

考虑这样一个例子:
!age < 20

由于逻辑非优先级最高, !age被结合在一起, 其结果仅可能是0或1, 那么整个表达式的结果永远为1

优先级

短路

逻辑运算是自左向右进行的, 若左侧的结果已经可以决定结果, 就不会执行右侧的计算

• 对于&&, 左侧有false不做右侧
• 对于||, 左侧有true不做右侧

条件运算符

ans = a ? b : c等价于

if(a){
  ans = b;
}else{
  ans = c;
}

这种写法看似简洁, 但当嵌套起来就会出现麻烦
注意: 条件运算符是自右向左结合的
w<x ? x+w : x<y ? x:y

尽量不要使用嵌套的条件表达式!!!

逗号运算

逗号是一个运算符, 用来连接两个表达式, 并以右侧表达式的值作为其结果
逗号的优先级是所有运算符中最低的, 所以其两侧的表达式会先计算
逗号的组合关系是自左向右, 左侧先算, 右侧后算, 取右侧的结果作为整体的结果
主要用途是for
for(i=0,j=10; i<j; i++,j--)

类型转换

当运算符两边出现不一致的类型时, 会自动转换成较宽/大的类型
宽/大是指能表达的数的范围更大

自动类型转换

整数: char → short → int → long → long long
浮点: int → float → double

对于printf, 任何小于int的类型都会被转化成int
float会被转化成double
但是, scanf不会

• 要输入short, 需要使用%hd
• 要输入long, 需要使用%ld
• 若要以整数的形式输入char, 必须先得到整数再交给char

强制类型转换

要把一个量强制转换成另一个类型(通常是较小的类型), 需要采用(类型)值的写法, 例如:

• (int)10.2
• (short)32

注意:

• 要留意安全性, 即大的数不一定能转换为小的数
  或者说, 小的变量不总能表达大的量
• 这种转换只是计算出了一个新的量, 并不会改变原来的量的值或者类型
• 强制类型转换的优先级高于四则运算

double a = 1.0;
double b = 2.0;
int i = (int)b / a;

上述的例子中, 先处理(int)b得到2, 再与浮点数a运算得到了浮点数的结果, 显然类型不一致, 会报错

针对手机端做出大改, 所有的板块也基本改成了错题本的形式, 任意添加
终于也是完成了存档的机制, 可以不用怕错题本丢失了
UI界面借鉴了心灵毒鸡汤, 平时有空会来两碗, 好喝, 力推
背景图片借用了infinity-pro的图库, 这是一款浏览器插件, 极大的美化了初始界面, 力推
背书机是本人高三时的创意, 算是最有意义也是最大的一个项目, 下面介绍一下开发经历

初代

分别制作了三份, 分别是 古诗/三百实词/英语词组
主要是考虑到老师的给出的资料很有规律性
灵光乍现, 利用简单的原理写成了程序

整合

功能要求上来了, 自然的组合成了一个大的
既然都整合了, 顺手添点新功能呗, 于是乎制作了错题本功能

壁纸

考虑到每次打开电脑都能立刻将背书机映入眼帘
在了解了Wallpaper Engine的制作方式后直接改装为桌面壁纸
中间由于界面不适应调整了多次, 这个过程加深了我对css的理解
最后迎战高考, 还添了一个倒计时的功能, 这个也是借鉴来的, 来自一个叫"倒计时Countdown"的大众级壁纸
p.s. 倒计时的四个圆圈点上去都有不同的效果, 这是我为了使用方便定的, 未作说明
p.s.p.s. 在WE还可以自定义控件样式, 就这个功能整了我一两天…

总结

使用效果还是很不错的, 应该归功于资料的规律排版
其实如果早一些学会正则表达式的话, 再乱的排版也能被快速格式化
此外, 毕竟借鉴了不少, 背书机也只能以自用为主, 要真正做出自己的产品还有long way to go
最后别忘了设计ta的初心–学习进步!

更新记录

2022年10月25日

• 排版针对三种手机宽幅设计了三种UI大小, 更加适配
• 捣鼓了很久的flex排版终于像样了
• 解决了小漏洞: 输出存档功能是没问题了, 但显示在屏幕上的时候, “
  “会变成换行
  其实修改很容易… 只要把innerHTML改换成innerText就可以了
• 关于壁纸无能为力, 试图使用 API接口, 虽然但是没玩明白, 之后改进

2022年10月28日

• 把载入错题换成了修改错题, 加了一个修改现有错题的功能, 更加方便!
• 在错题输出中加入了

• while 循环
• do-while 循环
• 例子 求对数
• 灵魂三问
• 例1 猜数游戏
• 例2 算平均数
• 例3 对多位数的逆序排列
• for 循环
• 例子 求素数
• 循环嵌套
• 跳出嵌套
  • 方法一 接力break
  • 方法二 goto
• 例题 数学题
• 例题 正序分解正整数
• 例题 求最大公约数
  • 法一 朴素解法
  • 法二 辗转相除法

while 循环

while (condition) {
    code; // 循环体
}

不多解释, 更详细的请看这篇↓
Day09_while和break

do-while 循环

do{
    code; // 循环体
} while (condition);

该结构进入循环的时候不做检查, 即, 代码至少运行一次
注意: 由于圆括号()表示的是语句, 因此在最后一定要记得加上分号;

例子 求对数

#include <stdio.h>
#include <math.h>

int main()
{
    int x;
    int ret = 0;

    printf("The num ?\n");
    scanf("%d", &x);

    int t = x;
    while (x > 1)
    {
        x /= 2;
        ret++;
    }
    printf("log2 of %d is %d", t, ret);

    if (pow(2, ret) != t)
    {
        printf("(approximately)");
    }

    return 0;
}

小套路: x在参与了运算后改变了, 先用一个t来备份

灵魂三问

1. 循环要执行几次?
2. 循环停止时输出了什么?
3. 循环结束后, 变量的值是多少?

例1 猜数游戏

计算机想一个数, 告诉玩家的猜测是大还是小, 直到猜中, 最后告诉用户猜了多少次
思路:

• 随机数, 存入number
• 一个负责记次数的变量count初始化为零
• 让用户输入一个数字a
• count递增
• 判断两者关系, 并输出"大/小"
• 如果不相等返回第三步
• 否则输出"猜中"次数

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    srand(time(0));
    int number = rand() % 100 + 1;
    int count;
    int a = 0;

    printf("我已经想好了一个1到100以内的整数\n");
    do
    {
        printf("请猜这个1到100之间的整数: ");
        scanf("%d", &a);
        count++;
        if (a > number)
            printf("你猜的数偏大\n");
        else if (a < number)
            printf("你猜的数偏小\n");
    } while (a != number);
    printf("答案正是%d, 你一共猜了%d次\n", number, count);

    return 0;
}

注释:

• srand(time(0));的作用是初始化随机数, 具体原理不多解释
  简单来说可以理解为 让随机数有随机数的样子
• 调用rand();会返回一个随机的整数, 注意区别于其他语言

例2 算平均数

输入一系列正整数, 最后输入-1表示结束, 输出平均数

#include <stdio.h>

int main()
{
    int number;
    int sum = 0;
    int count = 0;

    printf("计算平均数\n输入一系列正整数, 最后输入-1表示结束\n");
    scanf("%d", &number);
    while (number != -1)
    {
        sum += number;
        count++;
        scanf("%d", &number);
    }

    printf("平均数为: %.1f\n", 1.0 * sum / count);
    return 0;
}

例3 对多位数的逆序排列

#include <stdio.h>

int main()
{
    int x1 = 0, x2 = 0, digit = 0, ans = 0;
    printf("\n输入一个多位正整数: ");
    scanf("%d", &x1);
    x2 = x1;

    /* 方法一: 逐位输出 */
    printf("\n方法一的结果: ");
    while (x1 > 0)
    {
        digit = x1 % 10;
        x1 /= 10;
        printf("%d", digit);
    }

    /* 方法二: 获得转换后的数字再输出 */
    while (x2 > 0)
    {
        digit = x2 % 10;
        x2 /= 10;
        ans = ans * 10 + digit;
    }
    printf("\n方法二的结果: %d", ans);

    return 0;
}

输出结果如下:

输入一个多位正整数: 700

方法一的结果: 007
方法二的结果: 7

for 循环

引入: 要算阶乘 n!
此时要有一个计数器, 特点是:
开始时要声明, 每次要判断, 最后还要做++运算

for 的语法

for(count=0; count<max; count++)

作为理解, 可以把 for 读作 对于, 比如:

对于一开始的count=0, 当count<max时, 循环一次, 在每轮循环完成后, 使得count++

另外, 由于 计数器 在循环外没用, 因此可以在循环中定义ta

注意: for 会在循环一开始判断循环条件
这一点和 while 是类似的

以下是求阶乘的代码 (做了优化处理)

#include <stdio.h>

int main()
{
    int n;
    printf("输入要求阶乘的正整数: ");
    scanf("%d", &n);
    int i = n;
    int ans = 1;

    for (; n > 1; n--)
    {
        ans *= n;
    }
    
    printf("%d 的阶乘为: %d\n", i, ans);
    return 0;
}

该程序以巧妙的方式, 考虑到了n为0或1的情况

例子 求素数

#include <stdio.h>

int main()
{
    int x;
    printf("判断素数: ");
    scanf("%d", &x);

    int i;
    int isPrime = 1;
    for (i = 2; i < x / 2; i++)
    {
        if (x % i == 0)
        {
            isPrime = 0;
            break;
        }
    }
    if (isPrime == 1)
    {
        printf("是素数\n");
    }
    else
    {
        printf("不是素数\n");
    }
    return 0;
}

这里的 break 用于跳出循环
还有一个关键字 continue 用于进入下一轮循环

循环嵌套

获取1~100内所有素数

#include <stdio.h>

int main()
{
    int x;
    for (x = 2; x <= 100; x++)
    {
        int i;
        int isPrime = 1;
        for (i = 2; i <= x / 2; i++)
        {
            if (x % i == 0)
            {
                isPrime = 0;
                break;
            }
        }
        if (isPrime == 1)
        {
            printf("%3d", x);
        }
    }
    return 0;
}

获取前50个素数

#include <stdio.h>

int main()
{
    int x;
    int count = 0;
    for (x = 2; count < 50; x++)
    {
        int i;
        int isPrime = 1;
        for (i = 2; i < x / 2 + 1; i++)
        {
            if (x % i == 0)
            {
                isPrime = 0;
                break;
            }
        }
        if (isPrime == 1)
        {
            count++;
            printf("%d\t", x);
            if (count % 5 == 0)
            {
                printf("\n");
            }
        }
    }
    return 0;
}

值得注意的是, 本段程序的 for 并未使用计数器 x 作为判断标志
应当把 for 看作是 while 的简写形式, 不应当带有stereotype

跳出嵌套

凑硬币

#include <stdio.h>

int main()
{
    int x;
    int one, two, five;

    printf("要凑几块钱? ");
    scanf("%d", &x);

    for (one = 0; one <= x * 10; one++)
    {
        for (two = 0; two <= x * 10 / 2; two++)
        {
            for (five = 0; five <= x * 10 / 5; five++)
            {
                if (one + two * 2 + five * 5 == x * 10)
                {
                    printf("可以用% 3d个一角 加% 3d个二角 加% 3d个五角 得到%d元\n", one, two, five, x);
                }
            }
        }
    }

    return 0;
}

如果只要求得到一种情况就直接跳出三个循环呢?

方法一 接力break

#include <stdio.h>

int main()
{
    int x;
    int one, two, five;
    int exit = 0;

    printf("要凑几块钱? ");
    scanf("%d", &x);

    for (one = 0; one <= x * 10; one++)
    {
        for (two = 0; two <= x * 10 / 2; two++)
        {
            for (five = 0; five <= x * 10 / 5; five++)
            {
                if (one + two * 2 + five * 5 == x * 10)
                {
                    printf("可以用% 3d个一角 加% 3d个二角 加% 3d个五角 得到%d元\n", one, two, five, x);
                    exit = 1;
                    break;
                }
            }
            if (exit == 1)
                break;
        }
        if (exit == 1)
            break;
    }

    return 0;
}

方法二 goto

#include <stdio.h>

int main()
{
    int x;
    int one, two, five;
    int exit = 0;

    printf("要凑几块钱? ");
    scanf("%d", &x);

    for (one = 0; one <= x * 10; one++)
    {
        for (two = 0; two <= x * 10 / 2; two++)
        {
            for (five = 0; five <= x * 10 / 5; five++)
            {
                if (one + two * 2 + five * 5 == x * 10)
                {
                    printf("可以用% 3d个一角 加% 3d个二角 加% 3d个五角 得到%d元\n", one, two, five, x);
                    goto out;
                }
            }
        }
    }
out:
    return 0;
}

goto 受人诟病的原因在于, ta破坏了程序的结构性
但在上述的例子中, 其优点是非常显著的
因此, 仅仅在合适的场合使用goto, 其他地方尽量不使用

例题 数学题

求$f(n)=\sum \limits _{i=1}^1 \frac{1}{n}$

#include <stdio.h>

int main()
{
    int n;
    int i;
    double sum = 0.0;
    printf("n: ");
    scanf("%d", &n);
    for (i = 1; i <= n; i++)
    {
        sum += 1.0 / i;
    }
    printf("f(%d)=%f", n, sum);

    return 0;
}

求$f(n)=\sum \limits _{i=1}^1 \frac{1}{n}\cdot(-1)^{n+1}$

#include <stdio.h>

int main()
{
    int n;
    int i;
    double sign = 1.0;
    double sum = 0.0;
    printf("n: ");
    scanf("%d", &n);
    for (i = 1; i <= n; i++)
    {
        sum += sign / i;
        sign *= -1;
    }
    printf("f(%d)=%f", n, sum);

    return 0;
}

例题 正序分解正整数

输入非负整数, 正序输出每一位数字

• 输入: 13425
• 输出: 1 3 4 2 5

注意: 最后的数字后面没有空格

#include <stdio.h>

int main()
{
    int x;
    int mask=1;
    printf("请输入非负整数: ");
    scanf("%d", &x);

    /* 先获得数位 */
    int t = x;
    while (t > 9)
    {
        t /= 10;
        mask *= 10;
    } 

    /* 再逐个输出 */
    do{
        int d = x / mask;
        printf("%d", d);
        if(mask>9)
            printf(" ");
        x %= mask;
        mask /= 10;
    } while (mask > 0);
    printf("|<-这是数字的末尾\n");
    return 0;
}

本题综合了循环的多个技巧, 实属佳题
尤其要琢磨循环的条件是什么

例题 求最大公约数

输入两个数a&b, 输出其最大公约数

• 输入: 12 18
• 输出: 6

法一 朴素解法

#include <stdio.h>

int main()
{
    int a, b;
    printf("输入两个整数: \n");
    scanf("%d %d", &a, &b);

    int ans = 0;
    int i;
    for (i = 1; i <= a && i <= b; i++)
    {
        if (a % i == 0 && b % i == 0)
        {
            ans = i;
        }
    }

    printf("最大公约数是: %d\n", ans);
    return 0;
}

这里用到了逻辑运算, 在这个课程中还没教, 不过不算难
可以看C#课程中相关的知识点: Day06_Convert类型转换_加加减减_关系运算与逻辑判断

法二 辗转相除法

辗转相除法定义:

1. 如果b等于0, 计算结束, a就是最大公约数
2. 否则, 计算a除以b的余数, 再让a和b互换
3. 返回第一步

#include <stdio.h>

int main()
{
    int a, b;
    int t;
    printf("输入两个整数: \n");
    scanf("%d %d", &a, &b);

    while (b!=0)
    {
        t = a % b;
        a = b;
        b = t;
    }   

    printf("最大公约数是: %d\n", a);
    return 0;
}

• 做判断
• 关系运算
• 优先级
• 否则的话
• if再探
• 判断嵌套
• 级联的if-else if
• 多路分支 switch-case

做判断

条件判断用if, 语法如下

if(condition){
    code;
}

关系运算

计算两个值的关系称为 关系运算

注意: 当两个值的关系与关系运算符的预期

• 相符, 结果为整数1
• 不符, 结果为整数0

优先级

所有 关系运算符 的优先级 比 算术运算 低
但是, 比 赋值运算符 高

7 >= 3 + 4 中先计算 3 + 4
int r = a > 0 中先计算 a > 0

判断相等与否的 ==和!= 的优先级比其他关系运算符 低
而 连续的关系运算 是 从左到右进行的

5>3 == 6>4 两个比较的结果都是1, 最后判断相等, 结果为1
6>5>4 先计算6>5得到结果1, 接着运算1>4, 因此结果为0
a == b>0 先计算b>0, 再判断其结果与a是否一致

否则的话

与其他语言一样, 加一个else

if(condition){
    code 1;
}else{
    code 2;
}

if再探

if语句后面 未必 要带上花括号{}
如果要执行的只有一行语句, 可以不用花括号

判断嵌套

观察一下两组代码

/* find_max_1 */
int a, b, c;
scanf("%d %d %d", &a, &b, &c);

int max = 0;

if ( a>b ) {
    if( a>c ) {
        max = a;
    } else {
        max = c;
    }
} else {
    if ( b>c ) {
        max = b;
    } else {
        max = c;
    }
}

printf("The max is %d\n", max);

/* find_max_2 */
int a, b, c;
scanf("%d %d %d", &a, &b, &c);

int max = 0;

if ( a>b )
    if( a>c )
        max = a;
    else
        max = c;
else
    if ( b>c )
        max = b;
    else
        max = c;
    
printf("The max is %d\n", max);

两者在 语法上 完全相同
但对于阅读代码的人来说会造成困扰
这里需要注意两点:

1. 即便有缩进, 也不能暗示嵌套关系
2. else会按就近原则去找最近的if

第二种写法显然存在着巨大的出错风险
因此作为良好的编程习惯:

在if或者else后面总是加上{}
即便只有一条语句

级联的if-else if

if (condition_1){
    code_1;
} else if (conditon) {
    code_2;
} else {
    code_3
}

尽量别在级联的分支中做"实际操作"
即, 最好是 “单一出口”

多路分支 switch-case

switch (condition) {
    case c_1:
        code_1;
        break;
    case c_2:
        code_2;
        break;
    case c_3:
        code_3;
        break;
    default: 
        code_4;
}

注意:

• condition 只能是整数型的结果
• 各个 c_i 可以是常数, 也可以是由常数构成的表达式, 但一定有确切结果
• case只是一个路标, 在运行完ta对应的代码后并不会使得分支结构跳出, 只有break可以
• 一般来说, case和break都是配对的

• 表达式
• 运算符优先级
• 交换两个变量
• 复合赋值

表达式

表达式是一系列运算符和算子的组合, 用来计算一个值

• 运算符 (operator) 是指进行运算的行为/动作
• 算子 (operand) 是指参与运算的值, 可能是常数/变量/函数的返回值

举例: 计算时间差

输入两组"小时 时间", 结果也用相同格式打印出来

int hour1, minute1;
int hour2, minute2;

scanf("%d %d", &hour1, &minute1);
scanf("%d %d", &hour2, &minute2);

int delta_time = (hour2 - hour1) * 60 + minute2 - minute1;
printf("时间差是%d小时%d分钟", delta_time/60, delta_time%60);

运算符优先级

举例: 求平均值

写一个程序, 输俩整数, 输出平均值

int a,b;
printf("输入两个整数, 用空格空开\n");
scanf("%d %d", &a, &b);
double c = (a+b)/2.0;
printf("%d和%d的平均值=%f\n", a, b, c);

注意:

• 两个算子的运算符属于 双目运算符, 比如a+b
  类似的, 只有一个算子的成为的 单目运算符, 比如a*-b
  这种情况下, 运算符-对应的运算称为 “单目取负”, 其优先级高于乘法
• 在C语言中, 赋值运算符 = 被视作运算符, 而非特殊动作
  • 即, 赋值也属于运算, 也有结果
  • a=6的结果是6
  • a=b=6;
    • 等价于a=(b=6);
    • 等价于b=6; a=b;

交换两个变量

经典中的经典了

int a = 5;
int b = 6;
int t;

t=a;
a=b;
b=t;

printf("a=%d; b=%d",a,b);

经典方法二

int a = 5;
int b = 6;

a = b - a;
b = b - a;
a = a + b;

printf("a=%d; b=%d",a,b);

复合赋值

形如+= -= *= /= 和 %=的运算符称为 复合运算符

total+=12;
等价于
total = total + 12;

++ 和 -- 是特殊的单目运算符, 称为 递增运算符 和 递减运算符
该运算符放在算子的前后分别叫做 前缀形式 和 后缀形式
其中:

• 前缀得到的是运算之后的值
• 后缀可以理解为 “副作用”, 得到的是运算前的值(之后再加加减减)

目录

• 一刷C语言
• 第一个程序
• 变量
  • 变量的定义
  • 变量的名字
  • 赋值和初始化
  • 变量的类型
• 读取整数
• 常量

一刷C语言

学习平台显然是B站, 在比较了一些视频后考虑采用翁恺老师的视频
原因是: 声音好听/非机构/面向学生/朴实无华
视频传送门: 翁恺C语言-哔哩哔哩

第一个程序

#include <stdio.h>

int main()
{
    printf("Hello World!\n");

    return 0;
}

• 解释
  • printf负责输出
  • \n表示要换行
  • ""间是字符串

变量

变量的定义

int price=0;

• 变量名: price
• 类型: int
• 初始值: 0

变量是一个保存数据的地方, 可以参与之后的计算

变量定义的一般形式是: <类型名称> <变量名称>;

变量的名字

变量需要名字, 变量的名字是一种 “标识符” , 用以区别于其他变量
标识符有构造规则, 基本的原则是:

• 标识符只能由 字母/数字/下划线 组成
• 数字不得出现在第一个位置上
• 不可以将C语言的关键字用作标识符

赋值和初始化

a=b表示将b的值赋给a

在使用一个变量前应当对其赋值

变量的类型

int是一种变量的类型

变量被确定类型后不可改变

读取整数

scanf("%d", &price);
这行表达式要求scanf函数读取下一个整数(%d的作用), 并将读取的结果赋值给变量price

f字母的含义是’formatted’, 即读取的结果将被格式

在之后学完指针后将会讲解&的含义

常量

int change = 100 - price;
固定不变的数称为常量, 直接写在程序中的数字称为直接量(literal)

上面的表达式更好的写法应当是:
const int AMOUNT = 100;

好处是: 100的含义不言而喻, 代表一种金额
相比较而言, 原先的100被戏称为magic number (根本不知道什么意义)

const是一个 修饰符, 加在int前面, 用来给这个变量加上一个const(不变的)的属性
const属性表示, 该变量的值一旦被 初始化 就不能再做修改了

如果尝试为其再次赋值, 将会导致编译器报错

• 游戏头
• 初始化地图
• 绘制地图
• 输入姓名
• 核心游戏机制
• 最后调整Main函数
• 总结

游戏头

• 作用: 输出游戏初始界面

Console.ForegroundColor = ConsoleColor.Cyan;
Console.BackgroundColor = ConsoleColor.Black;
Console.WriteLine(@"
********************************************
********************************************
*******飞行棋游戏v1.0  By zhyDaDa***********
********************************************
********************************************
");

Console.ForegroundColor和Console.BackgroundColor分别用于设置控制台输出的前景色和背景色
@的使用能按照原格式输出
但要实现彩虹配色, 就得每输出一行, 就设置一遍前景色

初始化地图

• 作用: 加载地图所需要的资源, 为画地图做准备
• 地图的数据采用int存储(string更困难一些)
• 数字变成字符串的过程, 就是初始化地图的过程
• 由于所有方法都需要操作Maps数组, 因此建议使用静态字段模拟全局变量
• 定义地图的方法: 把存在特殊关卡的位置全部标出来

/// <summary>
/// 初始化地图, 修改地图数组
/// </summary>
public static void InitiateMap()
{
    int[] luckyTurn = { 6, 23, 40, 55, 69, 83 };    //幸运轮盘
    AddSpecialToMaps(luckyTurn, 1);
    int[] landMine = { 5, 13, 17, 33, 38, 50, 64, 80, 94 };     //地雷
    AddSpecialToMaps(landMine, 2);
    int[] pause = { 9, 27, 60, 93 };    //暂停
    AddSpecialToMaps(pause, 3);
    int[] timeTunnel = { 20, 25, 45, 63, 72, 88, 90 };  //时空隧道
    AddSpecialToMaps(timeTunnel, 4);
}

/// <summary>
/// 输入一个数组, 把数组中的每个数字对应的地图位置
/// 修改为输入的数值
/// </summary>
/// <param name="array">元素是若干索引</param>
/// <param name="sign">要改为的数字</param>
public static void AddSpecialToMaps(int[] array, int sign)
{
    for (int i = 0; i < array.Length; i++)
    {
        Maps[array[i]] = sign;
    }
}

绘制地图

• 符号最好是全角的

/// <summary>
/// 画地图
/// </summary>
public static void DrawMap()
{
    Console.ForegroundColor = ConsoleColor.White;
    //画第一行
    for (int i = 0; i < 30; i++)
    {

        //如果两位玩家位置重合, 且都在地图上画一对尖括号
        if (PlayerPos[0] == PlayerPos[1] && PlayerPos[0]==i)
        {
            Console.Write("<>");
        }
        else if (PlayerPos[0] == i)
        {
            Console.Write("Ａ");
        }
        else if (PlayerPos[0] == i)
        {
            Console.Write("Ｂ");
        }
        else
        {
            switch (Maps[i])
            {
                case 0:
                    Console.Write("□");
                    break;
                case 1:
                    Console.Write("⨷");
                    break;
                case 2:
                    Console.Write("☆");
                    break;
                case 3:
                    Console.Write("∆");
                    break;
                case 4:
                    Console.Write("卐");
                    break;
            }
        }
    }


}//这是方法的括号

• 这里需要将方法抽离出来
• 值得注意的是: 方法中最好不要打印控制台! 因此采用返回值的形式

/// <summary>
/// 返回要画出的一个格子
/// </summary>
/// <param name="i">对应的位置</param>
/// <returns>对应的格子的string</returns>
public static string TheStringOfTheMap(int i)
{
    string str = "";
    //如果两位玩家位置重合, 且都在地图上画一对尖括号
    if (PlayerPos[0] == PlayerPos[1] && PlayerPos[0] == i)
    {
        str = "§";
    }
    else if (PlayerPos[0] == i)
    {
        str = "Ａ";
    }
    else if (PlayerPos[0] == i)
    {
        str = "Ｂ";
    }
    else
    {
        switch (Maps[i])
        {
            case 0:
                //Console.ForegroundColor = ConsoleColor.White;
                str = "□";
                break;
            case 1:
                //Console.ForegroundColor = ConsoleColor.Green;
                str = "○";
                break;
            case 2:
                //Console.ForegroundColor = ConsoleColor.Red;
                str = "☆";
                break;
            case 3:
                //Console.ForegroundColor = ConsoleColor.Blue;
                str = "↓";
                break;
            case 4:
                //Console.ForegroundColor = ConsoleColor.DarkMagenta;
                str = "卐";
                break;
        }
    }

    return str;
}

p.s. 事实上, 要想让这些奇怪的符号在控制台排列整齐, 需要调整字体为黑体(win11特有)
p.s.p.s. 那些个//是原本想要变换颜色的, 不知怎么的产生了奇怪的错位, 于是乎放弃
p.s.p.s.p.s. 说不定以后自己(or读者)有可能调试成功, 我记录一下我逐步调试的发现:

就是当变色之后, 下一个要打印的字符会把之前打印的所有字符当成是半角的字符
ta就会跑到前面去, 接下来的字符就会和先前打印的重合造成重影

• 小竖行的处理相对简单, 只要打印空格就行
• 请注意空格数量

//换行
Console.WriteLine();

//画第一个数列(就一个)
for (int i = 30; i < 35; i++)
{
    for (int j = 0; j <= 28; j++)
    {
        Console.Write("  ");
    }
    Console.Write(TheStringOfTheMap(i));
    Console.WriteLine();
}

输入姓名

• 经典的判断
• 小问题: 全部输入空格的话其实应该是不被允许的(虽然这样没什么不好)

#region 输入玩家姓名
Console.WriteLine("请输入玩家A的姓名");
PlayerNames[0] = Console.ReadLine();
while (PlayerNames[0] == "")
{
    Console.WriteLine("玩家姓名不得为空, 请重新输入");
    PlayerNames[0] = Console.ReadLine();
}

Console.WriteLine("请输入玩家B的姓名");
PlayerNames[1] = Console.ReadLine();
while (PlayerNames[1] == ""|| PlayerNames[1]== PlayerNames[0])
{
    if (PlayerNames[1] == "")
    {
        Console.WriteLine("玩家姓名不得为空, 请重新输入");
    }
    else
    {
        Console.WriteLine("玩家姓名不得相同, 请重新输入");
    }
    PlayerNames[1] = Console.ReadLine();
}
#endregion

核心游戏机制

public static void PlayGame(int playerNumber)
{
    Console.WriteLine("{0}按任意键开始投掷骰子", PlayerNames[playerNumber]);
    Console.ReadKey(true);
    Random r = new Random();
    int rNumber = r.Next(1, 7);
    Console.WriteLine("{0}投出了点数{1}, 并向前移动{1}格, 按任意键行动", PlayerNames[playerNumber], rNumber);
    PlayerPos[playerNumber] += rNumber;
    ChangePos();
    Console.ReadKey(true);
    //判断踩到的格子的情况
    if (PlayerPos[0] == PlayerPos[1])
    {
        Console.WriteLine("玩家{0}踩到了玩家{1}, 玩家{2}退6格", PlayerNames[playerNumber], PlayerNames[1 - playerNumber], PlayerNames[1 - playerNumber]);
        PlayerPos[1 - playerNumber] -= 6;
        ChangePos();
        Console.ReadKey(true);
    }
    else
    {
        switch (Maps[PlayerPos[playerNumber]])
        {
            case 0:
                Console.WriteLine("玩家{0}踩到了普通方块, 安全", PlayerNames[playerNumber]);
                Console.ReadKey(true);
                break;
            case 1:
                Console.WriteLine("玩家{0}踩到了幸运轮盘, 请选择:\n1---交换位置\t2---轰炸对方", PlayerNames[playerNumber]);
                string input = Console.ReadLine();
                while (true)
                {
                    if (input == "1")
                    {
                        Console.WriteLine("玩家{0}和玩家{1}互换位置", PlayerNames[playerNumber], PlayerNames[1 - playerNumber]);
                        Console.ReadKey(true);
                        int temp = PlayerPos[0];
                        PlayerPos[0] = PlayerPos[1];
                        PlayerPos[1] = temp;
                        Console.WriteLine("交换成功! 按任意键继续");
                        Console.ReadKey(true);
                        break;
                    }
                    else if (input == "2")
                    {
                        Console.WriteLine("玩家{0}轰炸了玩家{1}", PlayerNames[playerNumber], PlayerNames[1 - playerNumber]);
                        Console.ReadKey(true);
                        PlayerPos[1-playerNumber] -= 6;
                        ChangePos();
                        Console.WriteLine("玩家{0}退了6格! 按任意键继续", PlayerNames[1 - playerNumber]);
                        Console.ReadKey(true);
                        break;
                    }
                    Console.WriteLine("只允许输入1或2, 1---交换位置\t2---轰炸对方");
                    input = Console.ReadLine();
                }
                break;
            case 2:
                Console.WriteLine("玩家{0}踩到了地雷, 退六格", PlayerNames[playerNumber]);
                PlayerPos[playerNumber] -= 6;
                ChangePos();
                Console.ReadKey(true);
                break;
            case 3:
                Console.WriteLine("玩家{0}踩到了暂停, 下一回合跳过", PlayerNames[playerNumber]);
                Flags[playerNumber] = true;
                Console.ReadKey(true);
                break;
            case 4:
                Console.WriteLine("玩家{0}踩到了时空隧道, 前进10格", PlayerNames[playerNumber]);
                PlayerPos[playerNumber] += 10;
                ChangePos();
                Console.ReadKey(true);
                break;
        }//switch的end
    }//判断的end

    ChangePos();
    Console.Clear();
    DrawMap();
}

为了防止出现被干出地图的情况发生
需要采用一个修正的机制

public static void ChangePos()
{
    if (PlayerPos[0] < 0)
    {
        PlayerPos[0] = 0;
    }
    if (PlayerPos[0] >= 99)
    {
        PlayerPos[0] = 99;
    }
    if (PlayerPos[1] < 0)
    {
        PlayerPos[1] = 0;
    }
    if (PlayerPos[1] >= 99)
    {
        PlayerPos[1] = 99;
    }
}

最后调整Main函数

static void Main()
{
    GameShow();
    Console.WriteLine();
    #region 输入玩家姓名
    Console.WriteLine("请输入玩家A的姓名");
    PlayerNames[0] = Console.ReadLine();
    while (PlayerNames[0] == "")
    {
        Console.WriteLine("玩家姓名不得为空, 请重新输入");
        PlayerNames[0] = Console.ReadLine();
    }

    Console.WriteLine("请输入玩家B的姓名");
    PlayerNames[1] = Console.ReadLine();
    while (PlayerNames[1] == "" || PlayerNames[1] == PlayerNames[0])
    {
        if (PlayerNames[1] == "")
        {
            Console.WriteLine("玩家姓名不得为空, 请重新输入");
        }
        else
        {
            Console.WriteLine("玩家姓名不得相同, 请重新输入");
        }
        PlayerNames[1] = Console.ReadLine();
    }
    #endregion
    //输入完姓名, 清屏
    Console.Clear();


    GameShow();
    Console.ForegroundColor = ConsoleColor.Green;
    Console.WriteLine("{0}的位置用A表示", PlayerNames[0]);
    Console.WriteLine("{0}的位置用B表示", PlayerNames[1]);
    Console.WriteLine("两人重合的位置用§表示");


    InitiateMap();
    DrawMap();

    //只要没到终点一直循环
    while (PlayerPos[0] < 99 && PlayerPos[1] < 99)
    {
        if (!Flags[0])
        {
            PlayGame(0);
        }
        else { Flags[0] = false; }
        if (PlayerPos[0] >= 99)
        {
            Console.BackgroundColor = ConsoleColor.Red;
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("玩家{0}获胜!!!", PlayerNames[0]);
            break;
        }
        if (!Flags[1])
        {
            PlayGame(1);
        }
        else { Flags[1] = false; }
        if (PlayerPos[1] >= 99)
        {
            Console.BackgroundColor = ConsoleColor.Red;
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("玩家{0}获胜!!!", PlayerNames[1]);
            break;
        }
    }

    Console.ReadKey();


}

总结

• 除了字符无法设置前景和后景色, 其他都不错
• 优化的话可以考虑更多的选项
• 以及, *在可以通关的前提下"的随机地图(防止一整排的地雷的出现)

简介

• 来源: 逛花瓣网的时候, 在形如"极简插画“一类词条下采集到的
• 作者: 资料来自网络

  法国女插画师Malika Favre现旅居伦敦。她的图案设计风格很独特，有着强烈的视觉审美感，风格偏几何化和简约化，擅长用较少的元素来表达丰富的内容。她创作的所有插图都弥漫着浓浓的法国味道，除了设计，她最爱五彩斑斓的鞋子和四处旅行。

• 作者的作品网站 https://www.malikafavre.com/
• 该系列的图集如下

临摹&评价

第一幅临摹, 左下角的配景小人完全画坏了, 最后是无奈的用色块涂上去
另外由于原图是模糊的, 因此远景完全没动脑筋, 直接原样照搬
事实上这么做只会完美实现"又费时又费力并且效果弱"的效果
但对她作品的曲线有了认识, 钢笔工具开始熟练

第二幅临摹, 说实话还满意
鸟是放大了另外画上去的, 效果就ok
但对于原图的依赖还是很大 为了达成一模一样, 因此我疯狂排直线, 希望能重合
正确的做法当然还是要达成 貌似神合 的效果
即, 记住大致, 然后具体线稿自己排

第三幅临摹, 较前面简单不少
但对于远方的小鸟还是没能领会怎么去画
其实这才是全画的精髓吧
原画中的鸟应当是很精细的完成后, 再缩到极小的

第四幅临摹, 有失误了
马路中有一个路肩画穿模了, 没剪干净
房子和路牌仍旧是无可奈何, 终究还是糊弄过去了
不过这次, 由于原画的动物究竟是什么没搞懂
于是乎终于自己找素材贴了个熊猫上去(搭不搭啥的已经不在意了)
然鹅它的影子没处理好(败笔不是一点点orz…)

第五幅可能是最快的
配景小人这次用心画了, 虽然但是影子很诡异就是了
远方仍旧有鸟, 依旧不知道到底怎么画的
干脆换做热气球(别问脑洞)
btw, 重复工具算是掌握了

最后一幅, 也是最满意的
因为所有的鸟的细节都放大之后认真重画了
包括对毛巾的描绘, 应该算是钢笔工具合格了
天上的鸟自己找的食物素材, 虽然不知道怎么打阴影, 但最后的效果和画风很吻合

• 总之, Malika Favre的作品都透露着迷人的浪漫
• 对这一个系列的临摹, 即便不能领会她的章法, 但绝对领教了流畅曲线(钢笔工具)和色彩(取色器)的使用

• 用于特定用途的实用工具, 功能较为简易
• 部分有抄袭/借鉴, 如站长工具, 侵删

一览表(点击名称跳转)

• 练习1
• 练习2
• 练习3

练习1

• 题目: 一个string类型的数组, 要输出其中最长的字符串
• 参考字符串: “Bernoulli”,“Fatou”,“Euler”,“Gauss”,“Riemann”,“Neumann”,“Newton”,“Maxwell”,“Kepler”,“Leibniz”,“Lagrange”

static void Main(string[] args) //Main函数
{  //代码从这里走起
    string[] names = { "Bernoulli", "Fatou", "Euler", "Gauss", "Riemann", "Neumann", "Newton", "Maxwell", "Kepler", "Leibniz", "Lagrange" };
    string max = GetLongest(names);
    Console.WriteLine(max);
}
public static string GetLongest(string[] s)
{
    string max = s[0];
    for (int i = 0; i < s.Length; i++)
    {
        if (s[i].Length > max.Length)
        {
            max = s[i];
        }
    }
    return max;
}

练习2

• 题目: 判断等地
• 判断依据: 90~100 为优, 80~89 为良…

static void Main(string[] args) //Main函数
{  //代码从这里走起
    while (true)
    {

        try
        {
            Console.WriteLine("请输入考试成绩");
            int input = Convert.ToInt32(Console.ReadLine());
            string grade = DecideGrade(input);
            Console.WriteLine("考试等地为{0}", grade);
            break;
        }
        catch
        {
            Console.WriteLine("成绩输入有误, 请重新输入");
        }
    }
    Console.ReadKey();
}
public static string DecideGrade(int s)
{
    s = s / 10;
    switch (s)
    {
        case 10:
        case 9:
            return "优";
        case 8:
            return "良";
        case 7:
            return "次";
        case 6:
            return "合格";
        default:
            return "不及格";
    }
}

练习3

• 计算任意个值的总和

static void Main(string[] args) //Main函数
{  //代码从这里走起
    int sum = GetSum2(1, 2, 3, 4, 5, 6, 7, 8);
    Console.WriteLine(sum);
}
public static int GetSum2(params int[] nums)
{
    int sum = 0;
    for (int i = 0; i < nums.Length; i++)
    {
        sum += nums[i];
    }
    return sum;
}

注意: 要想用方法来改变一个数值, 必须要通过返回值来实现
但是, 如果是改变数组, 不需要返回值

• 方法的重载
• 方法的递归

方法的重载

• 概念: 方法的重载是指, 方法名称相同, 但参数不同(应对不同参数采用不同方法)
• 举例: WriteLine这个方法对于各种类型的传参都生效, 因此"构成重载"
• 引入: 对于不同类型的两个相同类型的参数, 实现求和

public static void M(int a, int b, out int c)
{
    c = a + b;
}
public static void M(double a, double b, out double c)
{
    c = a + b;
}
public static void M(decimal a, decimal b, out decimal c)
{
    c = a + b;
}
public static void M(string a, string b, out string c)
{
    c = a + b;
}

• 注意: 如果两个方法返回值不同, 但形参一致, 不能构成重载
  即, 方法的重载和返回值没有关系

方法的递归

• 注意: 记得用return退出
• 备注: return退出递归程序会逐个退出

• 引入练习
• out参数
• out练习
• ref参数
• params可变参数

引入练习

• 求数组的最大值, 最小值, 总和, 平均值
• 由于返回多个同类型的值, 所以返回数组

static void Main(string[] args) //Main函数
{  //代码从这里走起
    int[] numbers = { 1, 2, 3, 4, 5, 6 };
    int[] res = GetMaxMinSumAvg(numbers);
    Console.WriteLine("最大值: {0}\n最小值: {1}\n总和: {2}\n平均值: {3}", res[0], res[1], res[2], res[3]);
}
/// <summary>
/// 输入整数数组, 返回一个数组
/// 元素依次是: 最大值, 最小值, 总和, 平均数
/// </summary>
/// <param name="numbers">数组</param>
/// <returns>数组</returns>
public static int[] GetMaxMinSumAvg(int[] numbers)
{
    int[] res = new int[4];
    res[0] = numbers[0];
    res[1] = numbers[0];
    res[2] = 0;
    for (int i = 0; i < numbers.Length; i++)
    {
        if (numbers[i] > res[0])    //修改最大值
        {
            res[0] = numbers[i];
        }
        if (numbers[i] < res[1])    //修改最小值
        {
            res[1] = numbers[i];
        }
        res[2] += numbers[i];
    }
    res[3] = res[2] / numbers.Length;
    return res;
}

但是, 如果要返回多个不同类型的值的时候, 返回数组就不行
此时, 考虑使用out参数

out参数

• out参数侧重于在一个方法中返回多个不同类型的值

• 注意:

  • 在main函数中可以不给那四个值赋值, 因为函数为其赋值
  • 实参形参前面都要记得带上out关键字

• 引入练习中使用out

static void Main(string[] args) //Main函数
{  //代码从这里走起
    int[] numbers = { 1, 2, 3, 9, 5, -6 };
    int max = 0;
    int min = 0;
    int sum = 0;
    int avg = 0;
    GetMaxMinSumAvg(numbers, out max, out min, out sum, out avg);
    Console.WriteLine("最大值: {0}\n最小值: {1}\n总和: {2}\n平均值: {3}", max, min, sum, avg);
}
/// <summary>
/// 计算一个整数数组的 最大值, 最小值, 总和, 平均数
/// </summary>
/// <param name="numbers">要求的数组</param>
/// <param name="max">多余返回的最大值</param>
/// <param name="min">多余返回的最小值</param>
/// <param name="sum">多余返回的总和</param>
/// <param name="avg">多余返回的平均值</param>
public static void GetMaxMinSumAvg(int[] numbers, out int max, out int min, out int sum, out int avg)
{
    max = numbers[0];
    min = numbers[0];
    sum = 0;
    for (int i = 0; i < numbers.Length; i++)
    {
        if (numbers[i] > max)    //修改最大值
        {
            max = numbers[i];
        }
        if (numbers[i] < min)    //修改最小值
        {
            min = numbers[i];
        }
        sum += numbers[i];
    }
    avg = sum / numbers.Length;
}

out练习

• 会提示错误原因的登录系统, 当然是要用方法的那种

static void Main(string[] args) //Main函数
{  //代码从这里走起
    Console.WriteLine("输入用户名");
    string name = Console.ReadLine();
    Console.WriteLine("请输入密码");
    string pwd = Console.ReadLine();
    string msg;
    bool b = IsLogin(name, pwd, out msg);
    Console.WriteLine("登录结果为: {0}\n登录信息: {1}", b, msg);

}
/// <summary>
/// 判断用户名和密码是否正确
/// </summary>
/// <param name="name">用户名</param>
/// <param name="pwd">密码</param>
/// <param name="msg">提示信息</param>
/// <returns>登陆成功返回true</returns>
public static bool IsLogin(string name, string pwd, out string msg)
{
    if (name =="admin" && pwd == "666666")
    {
        msg = "登陆成功";
        return true;
    }
    else if (name == "admin")
    {
        msg = "密码错误";
        return false;
    }
    else if (pwd == "666666")
    {
        msg = "用户名错误";
        return false;
    }
    else
    {
        msg = "未知错误";
        return false;
    }
}

• 模仿TryParse

public static bool MyTryParse(string s, out int result)
{
    result = 0;
    try
    {
        result = Convert.ToInt32(s);
        return true;
    }
    catch
    {
        return false;
    }
}

ref参数

• ref参数能够将一个变量带入方法中进行改变, 改变完成后, 再将改变后的参数导出方法
• 注意: ref参数要求在方法外必须为其赋值, 而方法内可以不赋值

弹幕里多次提到"指针", 我理解为内存地址

• 使用方法来交换两个int类型的变量

static void Main(string[] args) //Main函数
{  //代码从这里走起
    int n1 = 20;
    int n2 = 99;
    SwitchTwoInt(ref n1, ref n2);
    Console.WriteLine(n1 + "\n" + n2);
}

public static void SwitchTwoInt(ref int n1, ref int n2)
{
    n1 = n1 - n2;
    n2 = n1 + n2;
    n1 = n2 - n1;
}

params可变参数

• params可变参数能将实参列表中跟可变参数数组类型一致的元素都当做数组的元素去处理
• 注意: params可变参数必须是形参列表中最后一个参数

static void Main(string[] args) //Main函数
{  //代码从这里走起
    int sum1 = GetSum(21, 323, 3, 13, 2123, 21, 4);
    int[] nums = { 21, 323, 3, 13, 2123, 21, 4 };
    int sum2 = GetSum(nums);
    Console.WriteLine(sum1);
    Console.WriteLine(sum2);
}
public static int GetSum(params int[] nums)
{
    int sum = 0;
    for (int i = 0; i < nums.Length; i++)
    {
        sum += nums[i];
    }
    return sum;
}

• 复习
• 方法的调用问题
• 练习1
• 方法的概念
• 练习2
• 两个练习

复习

• 常量: 赋予初始值后, 不可以重新赋值 const int number = 10;
• 枚举: 可以和int兼容, 和string转换很复杂

public enum Gender
{
    男,
    女
}

string s = "男";
Gender g = (Gender)Enum.Parase(typeof(Gender), s);

• 结构: 字段可以存储多个值, 命名的时候记得带上下划线"_"

public struct Person
{
    public string _name;
    public age _age;
    public Gender _gender;
}

Person zsPerson;
zsPerson._name = "张三";
zsPerson._age = 20;
zsPerson._gender = Gender.男

• 数组: 一次性存储多个相同类型的变量
  数组的长度一旦声明不可改变

int[] numbers = new int[10];

• 数组操作: 冒泡排序

面试时体现领悟力使用

int[] numbers = { 123, 8, 445, 26, 45, 65, 46 };
for (int i = 0; i < numbers.Length - 1; i++)
{
    for (int j = 0; j < numbers.Length - i - 1; j++)
    {
        if (numbers[j] > numbers[j + 1])
        {
            int temp = numbers[j + 1];
            numbers[j + 1] = numbers[j];
            numbers[j] = temp;
        }
    }
}
for (int i = 0; i < numbers.Length - 1; i++)
{
    Console.Write(numbers[i] + "<");
}
Console.Write(numbers[numbers.Length - 1]);
Console.ReadKey();

平日里为了效率使用

int[] numbers = { 123, 8, 445, 26, 45, 65, 46 };
Array.Sort(numbers);
for (int i = 0; i < numbers.Length - 1; i++)
{
    Console.Write(numbers[i] + "<");
}
Console.Write(numbers[numbers.Length - 1]);
Array.Reverse(numbers);
for (int i = 0; i < numbers.Length; i++)
{
    Console.WriteLine(numbers[i]);
}
Console.ReadKey();

方法的调用问题

• 例子

static void Main(string[] args) //Main函数
{  //代码从这里走起
    int a = 3;
    Test();
    Console.WriteLine(a);
}
public static void Test()
{
    a += 5;
}

这个例子的运行结果是报错, 因为参数a在test中未命名

• 如果被调用者要获得调用者的值, 方法有二
  • 传参
  • 使用静态字段来模拟全局变量

public static void int _number = 10;

• 注意: C#中没有全局变量这一说
• 如果调用者要获得被调用者的值
  • 用return

练习1

• 写一个方法, 判断是否是闰年

static void Main(string[] args) //Main函数
{  //代码从这里走起
    bool b = IsRun(2022);
    Console.WriteLine(b);
}
/// <summary>
/// 判断给定的年份是否是闰年
/// </summary>
/// <param name="year">给定的年份</param>
/// <returns>是否是闰年</returns>
public static bool IsRun(int year)
{
    bool b = (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
    return b;
}

• 注意: "并非所有的代码路径都返回值" 的语法错误对应的情况是: 声明了返回值的类型但没有返回任何值

方法的概念

• 实参: 在传参时, 实实在在存在的参数
• 形参: 在方法中使用的形式上的参数, 作用域只在其方法内部
• 两者关系: 作用域不同, 没有必然的练习, 只有数据类型要求一致, 且两者都在内存中开辟空间

练习2

• 读取输入的整数, 如果输入是数字, 则返回, 否则提示用户重新输入

while (true)
{
    Console.WriteLine("请输入数字");

    try
    {
        int number = Convert.ToInt32(Console.ReadLine());
        Console.WriteLine(number);
        break;
    }
    catch
    {
        Console.WriteLine("输入有误");
    }
}
Console.ReadKey();

• 典型错误

Main(){
    NewMethod();
    Console.ReadKey();
}

原则: 方法的功能一定要单一 忌讳: 方法中出现提示用户输入的字眼

否则, 这就限定了这个方法只能在控制台程序中使用
而其他程序开发将不兼容
团队合作中也很讨厌

• 正确事例

static void Main(string[] args) //Main函数
{  //代码从这里走起
    Console.WriteLine("请输入一个整数");
    Console.WriteLine(GetNumber(Console.ReadLine()));
    Console.ReadKey();

}

/// <summary>
/// 判断用户的输入是否是数字
/// 是数字就返回
/// 不是, 就提示用户重新输入
/// </summary>
public static int GetNumber(string s)
{
    while (true)
    {
        try
        {
            int number = Convert.ToInt32(s);
            return number;
        }
        catch
        {
            Console.WriteLine("请重新输入");
            s = Console.ReadLine();
        }
    }
}

两个练习

• 只允许输入y和n, 用方法实现

static void Main(string[] args) //Main函数
{  //代码从这里走起
    // 方法的效果, 只输入y或n, 只要不是, 重新输入

    Console.WriteLine("请输入y或者n");
    Console.WriteLine(IsYesOrNo(Console.ReadLine()));
    Console.ReadKey();

}
/// <summary>
/// 限定用户只能输入yes或者no
/// </summary>
/// <param name="input">用户的输入</param>
/// <returns>"y"或者"n"</returns>
public static string IsYesOrNo(string input)
{
    while (true)
    {
        if (input == "y" || input == "n")
        {
            return input;
        }
        else
        {
            Console.WriteLine("只能输入y或者n, 请重新输入");
            input = Console.ReadLine();
        }
    }
}

• 计算输入数组的总和

static void Main(string[] args) //Main函数
{  //代码从这里走起
    int[] numbers = { 1, 2, 3, 4, 5, 6 };
    Console.WriteLine(GetSum(numbers));
}
/// <summary>
/// 输入整数数组, 返回其总和
/// </summary>
/// <param name="numbers">数组</param>
/// <returns>总和</returns>
public static int GetSum(int[] numbers)
{
    int sum = 0;
    for (int i = 0; i < numbers.Length; i++)
    {
        sum += numbers[i];
    }
    return sum;
}

方法

• 定义: 方法(函数)就是将一堆代码重用的机制
• 语法:

[public] static 返回值类型 方法名 ([参数列表])
{
    方法体;
}

• 说明

  • public: 访问修饰符
  • static: 静态的
  • 返回值: 如果没有, 写void
  • 方法名: Pascal
  • 参数列表: 完成方法必要的条件, 没参数也不可以省略小括号

• 注意: 自定义方法同Main方法同级, 应当写在Main之外

• 补充: return两个作用:

  • 可以直接停止并跳出当前的方法
  • 返回方法的返回值

• e.g.1 计算两个整数之间的最大值

class Class1
{
    static void Main(string[] args) //Main函数
    {  //代码从这里走起

        int n1 = 2;
        int n2 = 999;
        Console.WriteLine(Class1.GetMax(n1, n2));

    }

    /// <summary>
    /// 计算两个整数的最大值  
    /// </summary>
    /// <param name="n1">第一个整数</param>
    /// <param name="n2">第二个整数</param>
    /// <returns>两者中的最大值</returns>
    public static int GetMax(int n1,int n2)
    {
        return n1 > n2 ? n1 : n2;
    }
}

注意: 要学会写简单易懂的文档注释 引用方法的时候要记得写为类名.方法名

细节问题

• 写方法的过程, 先要想清楚参数, 至于返回值可以稍后修改
• 方法提示的左上角提示返回值的类型
• 在某些情况下, 类名是可以省略的, 如果写的方法和Main函数在同一个类中, 就可以省略

(课程第五天)总结

• 常量: 一旦赋值, 不能重新赋值
• 枚举: 规范开发
• 结构: 为了一次性声明多个不同类型的变量
  • 字段: 多个值
• 数组
  • 一次性存储多个相同类型的变量
  • 通过下标(索引)访问元素
  • 数组的取值和赋值
  • 数组长度一旦声明不可改变
  • 冒泡排序(Array.Sort()和Array.Reverse())
• 方法
  • 写方法
  • 调用方法
  • 参数
  • 返回值
  • return

计算数组的最大值/最小值/总和/平均值

• 随机长度, 随机值组成的整数数组

int[] nums = { 1, 2, 3, 4, 5, 6, -7, 8, 9, 90 };
int max = nums[0];
max = int.MinValue;
int min = nums[0];
min = int.MaxValue;
int sum = 0;
for (int i = 0; i < nums.Length; i++)
{
    if (nums[i] >= max)
    {
        max = nums[i];
    }
    if (nums[i] <= min)
    {
        min = nums[i];
    }
    sum += nums[i];
}
Console.WriteLine("数组的\n最大值是{0}\n最小值是{1}\n总和是{2}\n平均数是{3}", max, min, sum, sum / nums.Length);

给max int中的最小值, 给min int中的最大值
但是这不如赋值数组中的一项来的简单直接

翻转数组

• 将每个元素倒序排列

思路: 头尾互换, 交换次数是N/2, 例如5个数换2次

string[] s = { "我", "是", "好人", ";", "精", "英", "计", "划" };
for (int i = 0; i < s.Length / 2; i++)
{
    string temp = s[i];
    s[i] = s[s.Length - 1 - i];
    s[s.Length - 1 - i] = temp;
}
for (int i = 0; i < s.Length; i++)
{
    Console.Write(s[i]);
}
Console.ReadKey();

冒泡排序

• 将数组中的元素按大小排序
• 过程: 依次和后面的元素比较, 只要大于就交换一次

将[5,4,3,2,1,0]升序排序

int[] nums = { 5, 4, 3, 2, 1, 0 }; 
for (int i = 0; i < nums.Length-1; i++) //控制比较的次数, 六个数比5次, Length-1=5
{
    for (int j = 0; j < nums.Length-1-i; j++)   //控制每次比较中交换的次数, 枚举找规律
    {
        if (nums[j] > nums[j + 1])
        {
            int temp = nums[j + 1];
            nums[j + 1] = nums[j];
            nums[j] = temp;
        }
    }
}
for (int i = 0; i < nums.Length; i++)
{
    Console.Write(nums[i]);
}

相当于每次都把前面的i-1个数中最大的拉到最右边, 故一定可以排序

数组的定义

• 一次性存储多个相同类型的变量
• 语法

//法1
数组类型[] 数组名 = new 数组类型[数组长度]
int[] nums1 = new int[10];
//法2
int[] nums2 = {1,2,3};
//法3
int[] nums3 = new int[3]{1,2,3};
//法4
int[] nums3 = new int[]{1,2,3};

• 说明:

  • 声明数组时, 在内存中, 给每个元素赋予初始值(占内存)
  • 开辟多少内存空间取决于数组长度, 每一块空间称之为数组的一个元素
  • 每个元素的标号称为下标或索引(访问的依据)
  • 索引由0开始, 数组的最后一个元素的索引为数组长度-1
  • 索引超出数组界限会抛异常!
  • 数组长度一旦被声明就不再改变

• 不同数据类型对应的初始值

• 小复习
• 常量
• 枚举
• 结构

小复习

• 常见变量类型

  • int/double/string/char/bool/decimal

• 变量使用规则:

  • 声明$\rightarrow$赋值$\rightarrow$使用

• 命名规则

  • Camel 和 Pascal

• 运算符

  • 赋值: =
  • 复合赋值: += -= *= /= %=
  • 算数: + - * / % ++ –
  • 关系: > < >= <= == !=
  • 逻辑: && || !

• 语法结构

  • 分支结构: if if-else
  • 选择结构: while do-while for

常量

• 区别于变量, 常量是恒定的值, 不能被重新赋值
• 语法:

const 数据类型 常量名称 = 初始赋值; 

• 特点:
  • 不能被重新赋值

枚举

• 语法:

[public] enum 枚举名
{
    值1,
    值2,
    ...
} 

• 语法解释

  • []中括号代表可以省略(别把中括号写出来!)
  • public是访问修饰符. public是权限最高(或者也可以说是没有权限), 任何地方都可以访问(与private相对比)
  • enum是关键字, 用于声明枚举(其缩写为 Enumerate)
  • 枚举名要符合Pascal命名规范

• 意义

例如学员管理时, 要定义性别
不同程序员命名时, 可能出现如下情况

char gender = ‘男’;
string s1 = “female”;
bool b = true;

为了统一样式, 可以将枚举声明在 命名空间内 & 类的外面
使得所有的类都是用统一的变量类型

• 特点:

  • enum同int等变量类型一致, 都是用于存储数据
  • 区别仅在于变量的使用方式
  • 相当于自定义一种变量类型
  • 注意是点(.) 出来的

• 实例

namespace NAME
{
    public enum Seasons
    {
        春,
        夏,
        秋,
        冬
    }

    class class1
    {
        static ... Main ...
        {
            Season thisMonth = Seasons.夏
            // 最后输出的就是"夏"
        }
    }
}

枚举类型和int/string类型之间的转换

• 枚举类型默认可以和int类型互相转换
• 即, 两者兼容

public enum QQstate
{
    OnLine,
    OffLine,
    Leave = 9,
    Busy,
    QMe
}

• 枚举类型转换int类型

QQstate state = QQstate.OnLine;
int n = (int)state//隐式转换
Console.WriteLine(n);
Console.WriteLine((int)QQstate.OffLine);
Console.WriteLine((int)QQstate.Leave);
Console.WriteLine((int)QQstate.Busy);
Console.WriteLine((int)QQstate.QMe);

结果为
0 1 9 10 11

• int转换枚举类型

int n1 = 1
QQstate state = (QQstate)n1;
Console.WriteLine(state);
Console.WriteLine((QQstate)8);

结果为
OffLine 8
注意隐式失败不报错

• 注意: 所有类型都能转为string类型

• 调用.toString()就可以

• 字符串string转换为枚举类型较为麻烦

• 因为两者不兼容

• 此时应当调用Enum.parse(string1)

string s1 = "3";
string s2 = "夏";
string s3 = "99";
string s4 = "夏天";
Season month1 = (Season)Enum.Parse(typeof(Season), s1);
Season month2 = (Season)Enum.Parse(typeof(Season), s2);
Season month3 = (Season)Enum.Parse(typeof(Season), s3);
Season month4 = (Season)Enum.Parse(typeof(Season), s4);
Console.WriteLine(month1);
Console.WriteLine(month2);
Console.WriteLine(month3);
Console.WriteLine(month4);

结果很amazing
1: 冬
2: 夏
3: 99
4: 抛异常

• 注意: 数字不能转换返回数字本身; 文本不对应就会抛异常

结构

大学管理系统
要求数据: 姓名 性别 年龄 年级
问题是: 需要上千个变量

• 意义: 结构可以一次性声明多个变量
• 语法:

[public] struct 结构名
{
  成员;//可以理解为变量
}

• 注意: 放置的位置和枚举enum一样
• 举例:

public struct Person
{
  public string _name;//成为字段
  public int _age;
  public char _gender;
}

Person zsPerson;
zsPerson._name = "张三";
zsPerson._age = 21;
zsPerson._gender = '男';

Person lsPerson;
lsPerson._name = "李四";
lsPerson._age = 22;
lsPerson._gender = '男';

即 面向对象 编程(现在只能说很类似)

• 字段 与 变量 最本质的区别
  • 变量在程序运行的过程中, 只能存放一个值
  • 字段可以存储多个值
• 注意: 字段命名时一定记得加下划线

练习

• 给定一个叫MyColor的结构, 包含三个int成员red, blue, green
• 声明一个MyColor类型的变量, 为其成员赋值, 使之表示红色

public struct Mycolor
{
    public int _red;
    public int _green;
    public int _blue;
}
class Class1
{
    static void Main(string[] args) 
    {  //代码从这里走起

        Mycolor mc;
        mc._red = 255;
        mc._green = 0;
        mc._blue = 0;

    }
}

感想: 看似复杂无意义, 实际上是为了规范而发明的
当所有成员的代码组合起来的时候, 规范才有了意义
团队是合作的, 而非个人solo

• 务必使用电脑pc端, 点我开始游戏
• 手机端入口, 但目前只能玩经典模式, 触控按钮隐藏在图示的四个标红区域
• 操作提示: 按K键可以展示每个按键对应的功能, 空格键对应的就是经典模式

简介

• 内容: 高中阶段制作的一款2048游戏, 共6个模式
• 灵感: 背景泡泡来源于一个不那么正规的网址(还是不展示了, 侵删)
  计时器的来源:
• 特色: 6大特色模式 0. 经典模式: 忠实原味
  1. 暗黑竞速模式: 限速20秒
  2. 火红双倍模式: 每次移动会生成两个新数字
  3. X方块挑战模式: X方块对应着-64, 不消掉会卡位置, 两个X会合并为一个X, 但这样会扣128分
  4. 万宁模式: 每动一次, 所有数字翻倍! 但最多不超过8192, 纯粹娱乐
  5. 混沌模式: 各种方块(包括1,X,也有可能不生成)都有可能生成, 每一次移动后所有数字向右移动一格, 最右侧的那一列移动到最左边

备注:

1. 在这个期间攻破了DeepCopy这一核心技术, 搞清楚了存储空间的原理
2. 竞速模式刚做完, 班上就掀起了一股浪潮, 全名挑战最高分
   令我高兴的是, 大家都很尽兴; 令我伤心的是, 我的蓝牙键盘的方向键直接被按得报废了…😂

历代版本说明:

• V1–隐藏式触控按钮(在V4被遮挡)
• V2–高分榜
• V3–新增两个游戏模式
  –暗黑竞速模式
  –火红双倍模式
  –X方块挑战模式
• V4–加入动画制作
  –背景方块泡泡
  –开头展示动画
• V5–实现从外部读取设置
• V6–竞速模式限制按键频率

• 务必使用电脑pc端, 点我开始游戏
• 可能需要手动调整界面的缩放

简介

• 内容: 高中阶段制作的一款俄罗斯方块游戏, 稍加改编, 共有三种模式可供选择.
• 灵感: 来自本人在日本旅行期间扭蛋得到的俄罗斯方块掌中游戏机, 里面约有20种俄罗斯方块的模式, 虽然大多相似, 但启发我创造了一些可以实际操作的模式
  无论如何, 这对于练习js还是很有帮助的
  原本的思路是照抄网上的canvas, 但在弄清原理后自己用HTML实现了, 效果还不赖(p.s.网格都是一个个独立的div, 所以即便是缩放的操作也不会走样)
  背景的动效来源于一个脚本: jQuery+HTML5+Canvas实现四色3D多边形背景动画特效源码
  班上的wcx同学十分喜欢这个游戏, 对原本刺眼的配色提出了建设性建议, thanks!
• 特色: 柔和配色 / 险象环生的难度梯度 / 三种模式 / 高分榜 / GM模式(官方开挂)
  • 增强模式: 加入了5个方块组成的异形
  • 混沌模式: 开局随机生成灰色方块

历代版本说明

• 硬件

  1. 操作优化(运动暂停;Wall Kick)
  2. 分数
  3. 下一个Tetris
  4. 突破性技术:localStorage向数据丢失说拜拜!可持久保持玩家最高分记录!
  5. 加强模式:出现5连块
  6. 障碍模式:开局黑色块
  7. 实现分段提速&理想的Alerter提示板
  8. 实现操作2度提升,按住一直移动
  9. 应对每个模式的不同storage(应该放在start里做,切换模式即显示)

• 软装

  1. 基础框架搭建(背景大小合适化;版面布局)
  2. 现实footer注解,字号排版调整布局
  3. hsl色号平衡调整
  4. 仿FRVR护眼配色

• 待优化

  1. 新mode
  2. 玩家名称&技能
  3. 全版面像素风格化

• 务必使用电脑pc端, 点我开始游戏

简介

• 名称: 高中阶段制作的一款横版跳跃游戏, 游戏名来自jc同学, 中文名暂且称为"横版跳跃".
• 灵感: 来源于一个脚本: 激流勇进
  就连主题配色也没改动, 纯粹出于喜欢2D platform平台跳跃类游戏, 自己不断扩充制作而成.
• 特色: 过关提升 / iwanna-like / 平台跳跃 / 彩蛋 / 中偏高难度

备注:

1. bug还是有点的, 速度太快容易穿墙
2. 纯属娱乐, 由于核心代码照搬了原脚本, 侵权速删
3. 存档信息使用了LocalStorage, 只要了解点js就可以畅玩
4. 必须使用电脑游玩
5. 现在的版本算下来是V6.20.5, 大版本是一丁目, 想玩历史版本可以联系我

历代版本说明:

• 硬件

  1. 原版引擎
  2. 二段跳制作
  3. 制作了更多关卡以及关卡之间的切换
  4. 游戏存档技术
  5. 消除大量bug
  6. 格式规范化,量产准备已完善
  7. 彩蛋准备工作完成
  8. 存档机制修复
  9. 滑翔技能实现
  10. 掉落死亡和踩红死亡计数
  11. 制作了第三第四关
  12. 会移动的机关,trapClock计数系统
  13. 深度复制!突破技术壁垒!
  14. 制作了第五关
  15. 存档机制修复pro: 不会改变原来的重生点
  16. 制作了反重力领域技能
  17. 制作了第六关
  18. 完善所有关卡的成就
  19. 收尾工作(三成就)
  20. 检查并完善所有BUG

• 软装

  1. 居中视图
  2. 操作和按键的文字提示
  3. 配色方案
  4. 全屏尽享
  5. 系列故事/解密元素已加入

• 类型转换
• 循环的习题
• 随机数

类型转换

• 使用Convert.Int32("string"), 失败了会抛异常
• 使用int.Parse("string")效果一致

事实上, 前者就是调用后者, 因此后者效率更高(但可以忽略不计)

• int.TryParse("string")

int number1 = 10;
int number2 = 10;
bool a = int.TryParse("123", out number1);
bool b = int.TryParse("123abc", out number2);
Console.WriteLine(a);
Console.WriteLine(number1);
Console.WriteLine(b);
Console.WriteLine(number2);
Console.ReadLine();

>>> True
>>> 123
>>> False
>>> 0

• 作用:
  • 转换成功, 返回值是True, 转换结果输出给number
  • 转换失败, 返回值是False, 将0输出给number

循环的习题

• 录入五个人的年龄并计算平均年龄
  输入数据出现负数或者大于100, 立刻停止并报错

int sum = 0;
bool b = true;
for (int i = 0; i < 5; i++)
{
    Console.WriteLine("输入第{0}个人的年龄", i + 1);
    try
    {
        int age = Convert.ToInt32(Console.ReadLine());
        if (age >= 0 && age <= 100)
        {
            sum += age;
        }
        else
        {
            Console.WriteLine("输入的数据不在正确范围内, 程序退出");
            b = false;
            break;
        }
    }//try
    catch
    {
        Console.WriteLine("输入的不是年龄, 程序退出");
        b = false;
        break;
    }
}

if (b)
{
    Console.WriteLine("5个人的平均年龄是{0}", sum / 5);
}
Console.ReadKey();

三元表达式

• 语法:

表达式1 ? 表达式2 : 表达式3 

• 说明:
  • 表达式1 一般是个关系表达式
  • 表达式1是true, 则整个表达式就是表达式2的类型
  • 表达式1是false, 则整个表达式就是表达式3的类型
• 注意: 表达式2,3的数据类型必须一致

随机数

1. 创建能产生随机数的对象

Random r = new Random(); 

2. 调用方法

int rNumber = r.Next(1,10);

• 关键字 Continue
• for 循环(和嵌套)
• 程序调试

关键字 Continue

• 作用:

  1. 立刻结束本次循环
  2. 判断循环的条件
  3. 成立继续, 不成立退出

• 注意: 凡是continue后面的代码不会被访问到
  如果循环变量i++在循环最后, 一定要考虑到

• 练习: 找出100内所有质数

int i = 2;

while (i <= 100)
{
    //让i和比i小的(或者说i的一半)全部取余一遍, 有整除就continue
    int j = 2;
    bool b = true;
    while (j <= (i / 2))
    {
        if (i % j == 0)
        {
            b = false;
            break;
        }
        j++;
    }
    if (b)
    {
        Console.WriteLine(i);
    }
    i++;
}
Console.ReadKey();

自己写的时候错了两次, 一定要记得i++和j++

for 循环

• 语法:

for (int i = 0; i < length; i++)
{
  循环体
}

• for后面的三个表达式:

  • 声明循环变量, 记录循环次数
  • 循环条件
  • 改变循环的条件, 使循环条件会不成立

• 特点: 一般用于知道循环次数的循环

• 补充: 小窍门, for加tab两次可以跳出框架片段
  打forr可以跳出逆向循环的片段

练习

• 求水仙花数

for (int i = 100; i <= 999; i++)
{
    int a = i / 100;
    int b = i % 100 / 10;
    int c = i % 10;
    if (a * a * a + b * b * b + c * c * c == i)
    {
        Console.WriteLine(i);
    }
}
Console.ReadKey();

• 输出加法表

Console.WriteLine("输入正整数");
int number = Convert.ToInt32(Console.ReadLine());
for (int i = 0; i <= number; i++)
{
    Console.WriteLine("{0}+{1}={2}", i, number - i, number);
}
Console.ReadKey();

try-catch用户的输入是个好习惯(虽然但是懒得这么做orz)

for循环的嵌套

• 打印九九乘法表

for (int i = 1; i < 10; i++)
{
    for (int j = 1; j <= i; j++)
    {
        Console.Write("{0}x{1}={2}\t", i, j, i * j);
    }
    Console.Write("\n");
}
Console.ReadKey();

Console.Write()用来表示接着前面打印
Console.WriteLine()相当于Console.Write("xxx\n")

程序调试

• 功能:

  • 写完代码, 想看一下执行的过程
  • 写完程序, 发现没有按照预期执行

• 方法:

  • F11 逐行 单步调试
  • F10 逐过程调试
  • 断点调试

• 监视窗口: 红色的值代表刚刚发生变化

• 断点: 在最左侧灰色位置设置断点
  如果选中了一行代码, 可以按快捷键F9

• 注意: 黄色箭头是指将要执行但还没有执行的代码

• 循环结构 while
• 关键字 break
• 练习*3
• do-while 结构

循环结构 while

• while循环:

while(循环条件)
{
    循环体
}

• 执行过程:
  1. 循环运行到while处
  2. 首先判断循环条件是否成立
  3. 成立(即 返回true), 执行循环体
  4. 执行一遍, 返回1步骤
  5. 一旦不成立, 跳出while循环
• 一般总有一行代码, 能够改变循环条件, 使条件不再成立
• 循环条件永远成立的循环, 称之为 "死循环"

一定要分析出来 循环体 和 循环条件
琢磨一遍, 写在注释里, 养成思考的习惯!

关键字break的用法

• 作用:

  • 跳出switch-case结构
  • 跳出当前的while循环

• 特点: 一般不单独使用, 配合if使用

小练习*3

• 练习1: 输入班级总人数, 依次输入学员的成绩, 计算平均成绩和总成绩

bool b = true;
//避免出现异常就退出, 设置大循环
while (b) {

    //输入班级总人数, 依次输入学员的成绩, 计算平均成绩和总成绩
    //循环体: 接收成绩, 累加成绩
    //循环条件: 循环次数小于总人数

    //声明变量
    int number = 0;
    int i = 0;
    double sum = 0;

    //接收总人数
    Console.WriteLine("输入班级总人数(正整数)");
    try
    {
        number = Convert.ToInt32(Console.ReadLine());

        if (number > 0)
        {
            try
            {
                //按总人数展开循环, 依次接收成绩累加
                while (i < number)
                {
                    Console.WriteLine("请输入第{0}位学员的成绩", ++i);
                    sum += Convert.ToDouble(Console.ReadLine());
                }

                Console.WriteLine("这个班级总共{0}位学员\n总成绩是{1}\n平均成绩是{2:0.00}", number, sum, sum / number);
                b = false;  //这行代码能够运行就意味着程序生效, 退出循环

            }   //输入成绩不符合要求的try 结束括号
            catch
            {
                Console.WriteLine("成绩输入不符合规范, 程序退出");
            }
        }   //判断number是正数的结束括号
        else
        {
            Console.WriteLine("人数应当是正整数, 程序退出");
        }

    }   //这是try number接收的结束括号
    catch
    {
        Console.WriteLine("成绩输入不符合要求, 程序退出");
    }   //这是catch number接收的结束括号

    if (b)  //如果bool还是true, 就说明最终结果还未出现, 那么提示程序重启
    {
        Console.WriteLine("=========\n程序重启, 请认真填写\n再也没有什么嘻嘻哈哈了\n=========");
    }

}   //这里是最外圈的循环结束括号
Console.ReadKey();

**注意:**做题时, 先分析出来所需要的变量, 提前声明, 免得作用域出错
注: 以上代码是自己写的

• 练习2: 老师问:“这道题你会做了吗?” 回答y, 就放学; 回答n, 就再讲一遍, 再问一遍.
  • 一直到学生回答y才放学
  • 直到学生会or讲了5遍还不会, 都要放学

//循环体: 老师提问, 学生回答, 老师讲题
//循环的两个条件: 学生不会 且 讲的次数小于5遍

string answer = "";
int i = 0;

while (answer != "y" && i < 10)
{
    Console.WriteLine("这是我第{0}遍给你讲题, 你会了么?(y/n)", ++i);
    answer = Console.ReadLine();

    //如果回答是 就跳出循环
    if (answer == "y")
    {
        Console.WriteLine("会了就放学吧!");
        break;
    }
    else if (i == 5)    //第五次还不会就放学
    {
        Console.WriteLine("讲了5遍还不会也没必要讲了, 还是放学吧!");
        break;
    }
}

Console.ReadKey(); 

暂时不考虑非常严谨的异常处理

• 练习3: 2006年 学员80000人, 每年增长25%, 问哪一年人数达到20万人?

//循环体: 人数每年增长25%
//循环条件: 人数<20万

double people = 80000;
int year = 2006;
while (people < 200000)
{
    people *= 1.25;
    year++;
}
Console.WriteLine("到{0}年时, 人数达到20w", year);
Console.ReadKey(); 

简单数学, 所以数学功底要扎实

do-while 结构

• 语法:

do
{
    循环体
}while(循环条件);

• 执行过程:

  1. 首先执行一遍循环体
  2. 拿着执行结果 去判断循环条件
  3. 如果成立, 继续执行do中循环体
  4. 不成立就跳出循环

• 特点: 先循环, 再判断; 至少执行一次

注意: while后面带有封号

小练习

• 练习: 不断输入学生姓名, 输入q结束

string name = "";
do
{
    Console.WriteLine("输入姓名, 输入q结束");
    name = Console.ReadLine();
} while (name != "q");        

Console.ReadKey();

• 题目: 不断要求用户输入一个数字(假定均是正整数), 用户输入end时, 显示刚才输入的数字中最大的数字

string input = "";
int max = 0;
while (input != "end")
{
    Console.WriteLine("输入正整数, 若输入end将显示最大值");
    input = Console.ReadLine();
    if (input != "end")
    {
        try
        {
            int number = Convert.ToInt32(input);
            //打擂台
            if (number > max)
            {
                max = number;
            }
        }
        catch
        {
            Console.WriteLine("输入不符合规范, 重新输入");
        }
    }
    else    //end
    {
        Console.WriteLine("最大值是{0}", max);
    }
}
Console.ReadKey();

• 异常捕获

异常捕获

• 异常: 语法上没有错误, 在程序运行过程中, 由于某些原因程序出了问题, 不能再正常运行
• 出现异常很正常, 当我们知道程序中有可能出现异常时
  为了让程序更加坚强一些(不容易出现异常), 应当在程序中经常性地使用try-catch来进行异常捕获

哪行代码有可能出现异常, 就踹(try)他一脚

try
{
    有可能会出现异常的代码
}
catch
{
    出现异常时运行的代码
}

• 执行过程: try中的代码没有异常, 那么catch中的代码不会执行;
  如果catch中出现异常, 那么后面的代码全部不运行, 直接跳到catch中执行代码

记得多用异常捕获, 让异常和没异常一样

变量的作用域

• 变量的作用域就是变量能使用的范围
• 变量的作用域一般从声明变量的那一行开始, 一直到声明所在的花括号对应的结束花括号结束
• 在变量的作用域的范围之内, 我们可以访问并使用变量, 超出这个范围就访问不到了

switch-case 结构

• swich-case用来处理多条件的定值的判断
• 语法:

switch(变量或表达式的 值)
{
    case 值1: 要执行的代码;
    break;
    case 值2: 要执行的代码;
    break;
    case 值3: 要执行的代码;
    break;
    default: 要执行的代码;
    break;
}

• 执行过程:

  1. 先计算 变量或表达式的 值
  2. 拿这个返回的值依次和每个case后面带的值进行匹配
  3. 匹配成功就执行该case的代码
  4. 执行完成遇到break跳出该结构
  5. 如果均不匹配, 就看是否有default
  6. 如果有default, 就执行该代码
  7. 如果没有, 无事发生

• 注意: case后面的值 和 switch的变量 的类型要一致

练习

• 题目1: >=90 A档; [80,90) B档; …<60E档; 用switch-case做

Console.WriteLine("请输入考试成绩(100以内的正整数)");
int score = Convert.ToInt32(Console.ReadLine());
switch (score / 10)
{
    case 10:
    case 9:
        Console.WriteLine("A");
        break;
    case 8:
        Console.WriteLine("B");
        break;
    case 7:
        Console.WriteLine("C");
        break;
    case 6:
        Console.WriteLine("D");
        break;
    default:
        Console.WriteLine("E");
        break;
}
Console.ReadKey();

注意: case 10和case 9后的代码完全一样, 因此可以简写

• 题目2: 请用户输入年份 和 月份, 输出该月的天数(结合闰年)

//接收
Console.WriteLine("请输入一个年份");
try
{
    int year = Convert.ToInt32(Console.ReadLine());
    Console.WriteLine("请输入一个月份");
    try
    {
        int month = Convert.ToInt32(Console.ReadLine());// 可能性 1-12

        //声明变量
        int day = 0;

        if (month >= 1 && month <= 12)
        {

            switch (month)
            {
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10:
                case 12:
                    day = 31;
                    break;
                case 2:
                    //有平年闰年之分
                    bool b = (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
                    if (b)
                    {
                        day = 29;
                    }
                    else
                    {
                        day = 28;
                    }
                    break;
                default:
                    day = 30;
                    break;
            } //switch的括号

            Console.WriteLine("{0}年{1}月有{2}天", year, month, day);
        } //if判断的括号
        else
        {
            Console.WriteLine("输入月份不符合要求, 程序退出");
        }
    } //try月份的括号
    catch //和月份的try配对
    {
        Console.WriteLine("输入月份有误, 程序退出");
    }

} //try年份的括号
catch //和年份的try配对
{
    Console.WriteLine("输入的年份有误, 程序退出");
}
Console.ReadKey();

总结&反思
写代码的时候切忌: 不要边写边想异常, 这样只会乱套
全篇写完, 正常功能运行成功, 再回头做异常处理
全局考虑异常

• 判断闰年小练习
• 基本程序结构前瞻
• if / else / else if
• 四个分支结构练习

判断闰年小练习

Console.WriteLine("请输入要判断的年份");
int year = Convert.ToInt32(Console.ReadLine());
//闰年的两个条件:
//1. 能被400整除
//2. 能被4整除, 但不能被100整除

bool b = (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
Console.WriteLine(b);
Console.ReadKey();

逻辑与的优先级 大于 逻辑或

逻辑与也可以用一个"&“的符号
区别在于:

两个”&“如果遇到一个false, 之后的表达式就不再判断

一个”&“会把所有表达式全部判断一遍

结论是, 两个的效率更高, 推荐使用(逻辑或同理)

结构

• 顺序结构: 程序从Main函数进入, 从上至下一行一行地执行, 不会跳行
• 分支结构: if if-else
• 选择结构: if else-if switvh-case
• 循环结构: while do-while for foreach
• …

if结构

• 语法:

if(判断条件){
   要执行的代码;
}

• 判断条件: 一般为关系表达式 或 布尔类型的值
• 执行过程: 执行到if处, 首先判断括号中的判断条件
  • 若成立(即返回True), 则执行if后接的大括号中的代码
  • 若不成立(即返回False), 则跳过if后接的大括号中的代码, 继续向下执行
• 特点: 先判断, 再选择性执行代码
• 注意: 花括号外不加封号”;"

if-else 结构

• 语法:

if(判断条件成立){
   条件满足时执行的代码;
}else{
   条件不满足时执行的代码
}

• 特点: 先判断再执行, 选择其中一块代码执行
• 注意: else只和最近的if的配对

if else-if 结构

• 作用: 用来处理多条件的区间性的判断
  (之后的switch是处理多条件的定值性的判断)
• 语法: