哈喽，大家好，这篇文章可以说是一本书了，排版，码字耗费了很长的时间，10W+字 C 语言从入门到精通保姆级教程2021年版，觉得有价值记得一键三连支持。
另外，推荐一个外卖服务号，天天领取外卖红包，还有本地生活打折优惠。点击下方公众号关注。
计算机常识
什么是计算机程序?
什么是计算机语言 ?
常见的计算机语言类型有哪些?
什么是C语言?
C语言历史
C语言标准
C语言现状
为什么要学习C语言?
如何学好C语言
工欲善其事必先利其器
编写C语言程序用什么工具 ?
什么是Qt Creator ?
Qt Creator安装
什么是环境变量?
为什么要配置系统变量,不配置用户变量
Qt Creator快捷键
如何创建C语言程序
如何创建C语言文件
C语言程序组成
函数定义格式
如何执行定义好的函数
如何运行编写好的程序
main函数注意点及其它写法
C语言程序练习
初学者如何避免程序出现BUG
多语言对比
什么是注释?
为什么要使用注释?
注释的分类
注释的注意点
注释的应用场景
使用注释的好处
什么是关键字?
关键字分类
什么是标识符?
标识符命名规则
练习
标识符命名规范
什么是数据？
数据分类
C语言数据类型
什么是常量?
常量的类型
什么是变量?
如何定义变量
如何使用变量？
变量的初始化
如何修改变量值?
变量之间的值传递
如何查看变量的值?
变量的作用域
变量内存分析（简单版）
printf函数
Scanf函数
scanf运行原理
putchar和getchar
运算符基本概念
运算符分类
运算符的优先级和结合性
算数运算符
赋值运算符
自增自减运算符
sizeof运算符
逗号运算符
关系运算符
逻辑运算符
三目运算符
类型转换
阶段练习
流程控制基本概念
选择结构
选择结构if
选择结构switch
循环结构
循环结构while
循环结构do while
循环结构for
四大跳转
循环的嵌套
图形打印
函数基本概念
函数的分类
函数的定义
函数的参数和返回值
函数的声明
main函数分析
递归函数(了解)
进制基本概念
进制转换
十进制小数转换为二进制小数
二进制小数转换为十进制小数
原码反码补码
位运算符
变量内存分析
char类型内存存储细节
类型说明符
short和long
signed和unsigned
数组的基本概念
定义数组
初始化数组
数组的使用
数组的遍历
数组长度计算方法
练习
数组内部存储细节
数组的越界问题
数组注意事项
数组和函数
数组元素作为函数参数
数组名作为函数参数
数组名作函数参数的注意点
计数排序（Counting Sort）
选择排序
冒泡排序
插入排序
希尔排序
折半查找
进制转换(查表法)
二维数组
二维数组的定义
二维数组的初始化
二维数组的应用场景
二维数组的遍历和存储
二维数组的遍历
二维数组的存储
二维数组与函数
二维数组作为函数参数注意点
作业
字符串的基本概念
字符串的初始化
字符串输出
字符串常用方法
练习
字符串数组基本概念
指针基本概念
什么是指针
什么是指针变量
定义指针变量的格式
指针变量的初始化方法
访问指针所指向的存储空间
指针类型
二级指针
练习
指针访问数组元素
指针与字符串
指向函数指针
什么是结构体
定义结构体类型
定义结构体变量
结构体成员访问
结构体变量的初始化
结构体类型作用域
结构体数组
结构体指针
结构体内存分析
结构体变量占用存储空间大小
结构体嵌套定义
结构体和函数
共用体
枚举
全局变量和局部变量
auto和register关键字
static关键字
extern关键字
static与extern对函数的作用
Qt Creator编译过程做了什么?
计算机是运算过程分析
预处理指令
预处理指令的概念
宏定义
带参数的宏定义
条件编译
typedef关键字
宏定义与函数以及typedef区别
const关键字
如何使用const?
内存管理
进程空间
栈内存(Stack)
堆内存(Heap)
malloc函数
free函数
calloc函数
realloc函数
链表
静态链表
动态链表
动态链表头插法
动态链表尾插法
动态链优化
链表销毁
链表长度计算
链表查找
链表删除
作业
文件基本概念
文件的打开和关闭
一次读写一个字符
一次读写一行字符
一次读写一块数据
读写结构体
其它文件操作函数
什么是计算机?
顾名思义，就是能够进行数据运算的机器(台式电脑、笔记本电脑、平板电脑、智能手机)
计算机_百度百科
计算机的发明者是谁 ?
关于电子计算机的发明者是谁这一问题，有好几种答案:
1936年英国数学家图灵首先提出了一种以程序和输入数据相互作用产生输出的计算机构想，后人将这种机器命名为通用图灵计算机
1938年克兰德·楚泽发明了首台采用继电器进行工作的计算机,这台计算机命名为Z1，但是继电器是机械式的，并不是完全的电子器材
1942年阿坦那索夫和贝利发明了首台采用真空管*的计算机，这台计算机命名为ABC
1946年ENIAC诞生,它拥有了今天计算机的主要结构和功能，是通用计算机
现在世界上公认的第一台现代电子计算机是1946年在美国宾夕法尼亚大学诞生的ENIAC(Electronic Numerical Integrator And Calculator)
计算机特点是什么?
计算机是一种电器, 所以计算机只能识别两种状态, 一种是通电一种是断电
正是因为如此, 最初ENIAC的程序是由很多开关和连接电线来完成的。但是这样导致改动一次程序要花很长时间(需要人工重新设置很多开关的状态和连接线)
为了提高效率,工程师们想能不能把程序和数据都放在存储器中, 数学家冯·诺依曼将这个思想以数学语言系统阐述，提出了存储程序计算机模型(这是所谓的冯·诺依曼机)
那利用数学语言如何表示计算机能够识别的通电和断电两种状态呢?
0和1更准确的是应该是高电平和低电平, 但是这个不用了解, 只需要知道计算机只能识别0和1以及存储的数据都是由0和1组成的即可。
计算机程序是为了告诉计算机"做某件事或解决某个问题"而用"计算机语言编写的命令集合(语句)
只要让计算机执行这个程序,计算机就会自动地、有条不紊地进行工作,计算机的一切操作都是由程序控制的,离开程序,计算机将一事无成
现实生活中你如何告诉别人如何做某件事或者解决某个问题?
1 + 1MOV AX, 1 ADD AX, 110111000 00000001 00000000 00000101 00000001 00000000
“初,世间无语言,仅电路与连线。及大牛出,天地开,始有 FORTRAN、 LISP、ALGOL 随之, 乃有万种语”
当你想了解底层原理时,你才会发现后悔当初没有学习C语言 当你想学习一门新的语言时, 你才会发现后悔当初没有学习C语言 当你使用一些高级框架、甚至系统框架时发现提供的API都是C语言编写的, 你才发现后悔当初没有学习C语言 学好数理化,走遍天下都不拍 学好C语言,再多语言都不怕
| 学习本套课程之前 | 学习本套课程中 | 学习本套课程之后 |
|---|---|---|
 |  |
|
集成开发环境（IDE，Integrated Development Environment ）是用于提供程序开发环境的应用程序，一般包括代码编辑器、编译器、调试器和图形用户界面等工具。集成了代码编写功能、分析功能、编译功能、调试功能等一体化的开发软件服务套。
http://download.qt.io/
以管理身份运行离线安装包
下一步,下一步,下一步,等待ing...
注意安装路径中最好不要出现中文
对于初学者而言全选是最简单的方式(重点!!!)
配置Qt Creator开发环境变量
你的安装路径\5.11.0\mingw53_32\bin 你的安装路径\Tools\mingw530_32\bin
手机有很多功能, "开机","关机","打电话","发短信","拍照"等等
手机中的每一个功能就相当于C语言程序中的一个程序段(函数)
众多功能中总有一个会被先执行,不可能多个功能一起执行
想使用手机必须先执行手机的开机功能
所以C语言程序也一样,由众多功能、众多程序段组成, 众多C语言程序段中总有一个会被先执行, 这个先执行的程序段我们称之为"主函数"
一个C语言程序由多个"函数"构成,每个函数有自己的功能
一个程序有且只有一个主函数
如果一个程序没有主函数,则这个程序不具备运行能力
程序运行时系统会自动调用主函数,而其它函数需要开发者手动调用
主函数有固定书写的格式和范写
int main() {
// insert code here...
return 0;
}
int call() {
return 0;
}
int main() {
call();
return 0;
}
int call(){
return 0;
}
int main(){
call();
printf();
return 0;
}
printf("hello world\n");
#include <stdio.h>
int call(){
return 0;
}
int main(){
call();
printf("hello world\n");
return 0;
}
int main(){
printf("hello world\n") // 如果没有分号编译时会报错
return 0;
}
int main(){
// 如果没有分号,多条语句合并到一行时, 系统不知道从什么地方到什么地方是一条完整语句
printf("hello world\n") return 0;
}
int main(){
printf("hello world\n"); // 这里的分号如果是中文的分号就会报错
return 0;
}
int main(){
return 0;
}
int main(){ // 编译时会报错, 重复定义
return 0;
}
int call(){ // 编译时报错, 因为只有call函数, 没有main函数
return 0;
}
int mian(){ // 编译时报错, 因为main函数的名称写错了,还是相当于没有main函数
return 0;
}
#include <stdio.h>
main(){ // 不会报错
printf("hello world\n");
return 0;
}
#include <stdio.h>
void main(){ // 不会报错
printf("hello world\n");
return 0;
}
int main(){ // 不会报错
printf("hello world\n");
}
#include <stdio.h>
int main(){
printf("hello world\n");
return 0;
}
Tips: 语法错误：编译器会直接报错 逻辑错误：没有语法错误，只不过运行结果不正确
*** ***
*********
*******
****
**
printf(" *** *** \n");
printf("*********\n");
printf(" *******\n");
printf(" ****\n");
printf(" **\n");
printf(" *** *** \n*********\n *******\n ****\n **\n");
int i = 0;
while (1) {
if (i % 2 == 0) {
printf(" *** *** \n");
printf("*********\n");
printf(" *******\n");
printf(" ****\n");
printf(" **\n");
}else
{
printf("\n");
printf(" ** ** \n");
printf(" *******\n");
printf(" *****\n");
printf(" **\n");
}
sleep(1);
i++;
system("cls");
}
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
. ' \\| |// `.
/ \\||| : |||// \
/ _||||| -:- |||||- \
| | \\\ - /// | |
| \_| ''\---/'' | |
\ .-\__ `-` ___/-. /
___`. .' /--.--\ `. . __
."" '< `.___\_<|>_/___.' >'"".
| | : `- \`.;`\ _ /`;.`/ - ` : | |
\ \ `-. \_ __\ /__ _/ .-` / /
======`-.____`-.___\_____/___.-`____.-'======
`=---='
.............................................
佛祖保佑 有无BUG
━━━━━━神兽出没━━━━━━
┏┓ ┏┓
┏┛┻━━━━━━┛┻┓
┃ ┃
┃ ━ ┃
┃ ┳┛ ┗┳ ┃
┃ ┃
┃ ┻ ┃
┃ ┃
┗━┓ ┏━┛Code is far away from bug with the animal protecting
┃ ┃ 神兽保佑,代码无bug
┃ ┃
┃ ┗━━━┓
┃ ┣┓
┃ ┏━━┛┛
┗┓┓┏━┳┓┏┛
┃┫┫ ┃┫┫
┗┻┛ ┗┻┛
━━━━━━感觉萌萌哒━━━━━━
´´´´´´´´██´´´´´´´
´´´´´´´████´´´´´´
´´´´´████████´´´´
´´`´███▒▒▒▒███´´´´´
´´´███▒●▒▒●▒██´´´
´´´███▒▒▒▒▒▒██´´´´´
´´´███▒▒▒▒██´ 项目：第一个C语言程序
´´██████▒▒███´´´´´ 语言：C语言
´██████▒▒▒▒███´´ 编辑器：Qt Creator
██████▒▒▒▒▒▒███´´´´ 版本控制：git-github
´´▓▓▓▓▓▓▓▓▓▓▓▓▓▒´´ 代码风格：江哥style
´´▒▒▒▒▓▓▓▓▓▓▓▓▓▒´´´´´
´.▒▒▒´´▓▓▓▓▓▓▓▓▒´´´´´
´.▒▒´´´´▓▓▓▓▓▓▓▒
..▒▒.´´´´▓▓▓▓▓▓▓▒
´▒▒▒▒▒▒▒▒▒▒▒▒
´´´´´´´´´███████´´´´´
´´´´´´´´████████´´´´´´´
´´´´´´´█████████´´´´´´
´´´´´´██████████´´´´ 大部分人都在关注你飞的高不高，却没人在乎你飞的累不累，这就是现实！
´´´´´´██████████´´´ 我从不相信梦想，我，只，相，信，自，己！
´´´´´´´█████████´´
´´´´´´´█████████´´´
´´´´´´´´████████´´´´´
________▒▒▒▒▒
_________▒▒▒▒
_________▒▒▒▒
________▒▒_▒▒
_______▒▒__▒▒
_____ ▒▒___▒▒
_____▒▒___▒▒
____▒▒____▒▒
___▒▒_____▒▒
███____ ▒▒
████____███
█ _███_ _█_███
——————————————————————————女神保佑，代码无bug——————————————————————
#include<stdio.h>
int main() {
printf("南哥带你装B带你飞");
return 0;
}
#include<iostream>
using namespace std;
int main() {
cout << "南哥带你装B带你飞" << endl;
return 0;
}
#import <Foundation/Foundation.h>
int main() {
NSLog(@"南哥带你装B带你飞");
return 0;
}
class Test
{
public static viod main()
{
system.out.println("南哥带你装B带你飞");
}
}
package main
import "fmt" //引入fmt库
func main() {
fmt.Println("南哥带你装B带你飞")
}
void printMap(char map[6][7] , int row, int col);
int main(int argc, const char * argv[])
{
char map[6][7] = {
{'#', '#', '#', '#', '#', '#', '#'},
{'#', ' ', ' ', ' ', '#' ,' ', ' '},
{'#', 'R', ' ', '#', '#', ' ', '#'},
{'#', ' ', ' ', ' ', '#', ' ', '#'},
{'#', '#', ' ', ' ', ' ', ' ', '#'},
{'#', '#', '#', '#', '#', '#', '#'}
};
int row = sizeof(map)/sizeof(map[0]);
int col = sizeof(map[0])/ sizeof(map[0][0]);
printMap(map, row, col);
int pRow = 2;
int pCol = 1;
int endRow = 1;
int endCol = 6;
while ('R' != map[endRow][endCol]) {
printf("亲, 请输入相应的操作\n");
printf("w(向上走) s(向下走) a(向左走) d(向右走)\n");
char run;
run = getchar();
switch (run) {
case 's':
if ('#' != map[pRow + 1][pCol]) {
map[pRow][pCol] = ' ';
pRow++;//3
map[pRow][pCol] = 'R';
}
break;
case 'w':
if ('#' != map[pRow - 1][pCol]) {
map[pRow][pCol] = ' ';
pRow--;
map[pRow][pCol] = 'R';
}
break;
case 'a':
if ('#' != map[pRow][pCol - 1]) {
map[pRow][pCol] = ' ';
pCol--;
map[pRow][pCol] = 'R';
}
break;
case 'd':
if ('#' != map[pRow][pCol + 1]) {
map[pRow][pCol] = ' ';
pCol++;
map[pRow][pCol] = 'R';
}
break;
}
printMap(map, row, col);
}
printf("你太牛X了\n");
printf("想挑战自己,请购买完整版本\n");
return 0;
}
void printMap(char map[6][7] , int row, int col)
{
system("cls");
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
printf("%c", map[i][j]);
}
printf("\n");
}
}
/*
R代表一个人
#代表一堵墙
// 0123456
####### // 0
# # // 1
#R ## # // 2
# # # // 3
## # // 4
####### // 5
分析:
>1.保存地图(二维数组)
>2.输出地图
>3.操作R前进(控制小人行走)
3.1.接收用户输入(scanf/getchar)
w(向上走) s(向下走) a(向左走) d(向右走)
3.2.判断用户的输入,控制小人行走
3.2.1.替换二维数组中保存的数据
(
1.判断是否可以修改(如果不是#就可以修改)
2.修改现有位置为空白
3.修改下一步为R
)
3.3.输出修改后的二维数组
4.判断用户是否走出出口
*/
// 声明打印地图方法
void printMap(char map[6][7] , int row, int col);
int main(int argc, const char * argv[])
{
// 1.定义二维数组保存迷宫地图
char map[6][7] = {
{'#', '#', '#', '#', '#', '#', '#'},
{'#', ' ', ' ', ' ', '#' ,' ', ' '},
{'#', 'R', ' ', '#', '#', ' ', '#'},
{'#', ' ', ' ', ' ', '#', ' ', '#'},
{'#', '#', ' ', ' ', ' ', ' ', '#'},
{'#', '#', '#', '#', '#', '#', '#'}
};
// 2.计算地图行数和列数
int row = sizeof(map)/sizeof(map[0]);
int col = sizeof(map[0])/ sizeof(map[0][0]);
// 3.输出地图
printMap(map, row, col);
// 4.定义变量记录人物位置
int pRow = 2;
int pCol = 1;
// 5.定义变量记录出口的位置
int endRow = 1;
int endCol = 6;
// 6.控制人物行走
while ('R' != map[endRow][endCol]) {
// 6.1提示用户如何控制人物行走
printf("亲, 请输入相应的操作\n");
printf("w(向上走) s(向下走) a(向左走) d(向右走)\n");
char run;
run = getchar();
// 6.2根据用户输入控制人物行走
switch (run) {
case 's':
if ('#' != map[pRow + 1][pCol]) {
map[pRow][pCol] = ' ';
pRow++;//3
map[pRow][pCol] = 'R';
}
break;
case 'w':
if ('#' != map[pRow - 1][pCol]) {
map[pRow][pCol] = ' ';
pRow--;
map[pRow][pCol] = 'R';
}
break;
case 'a':
if ('#' != map[pRow][pCol - 1]) {
map[pRow][pCol] = ' ';
pCol--;
map[pRow][pCol] = 'R';
}
break;
case 'd':
if ('#' != map[pRow][pCol + 1]) {
map[pRow][pCol] = ' ';
pCol++;
map[pRow][pCol] = 'R';
}
break;
}
// 6.3重新输出行走之后的地图
printMap(map, row, col);
}
printf("你太牛X了\n");
printf("想挑战自己,请购买完整版本\n");
return 0;
}
/**
* @brief printMap
* @param map 需要打印的二维数组
* @param row 二维数组的行数
* @param col 二维数组的列数
*/
void printMap(char map[6][7] , int row, int col)
{
// 为了保证窗口的干净整洁, 每次打印都先清空上一次的打印
system("cls");
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
printf("%c", map[i][j]);
}
printf("\n");
}
}
单行注释
多行注释
// 南哥 // 公号代码情缘
// /* 江哥 */
// 瓜哥
/*
// 作者：LNJ
// 描述：第一个C语言程序作用：这是一个主函数，C程序的入口点
*/
/*
哈哈哈
/*嘻嘻嘻*/
呵呵呵
*/
/*
R代表一个人
#代表一堵墙
// 0123456
####### // 0
# # // 1
#R ## # // 2
# # # // 3
## # // 4
####### // 5
分析:
>1.保存地图(二维数组)
>2.输出地图
>3.操作R前进(控制小人行走)
3.1.接收用户输入(scanf/getchar)
w(向上走) s(向下走) a(向左走) d(向右走)
3.2.判断用户的输入,控制小人行走
3.2.1.替换二维数组中保存的数据
(
1.判断是否可以修改(如果不是#就可以修改)
2.修改现有位置为空白
3.修改下一步为R
)
3.3.输出修改后的二维数组
4.判断用户是否走出出口
*/
// 2.计算地图行数和列数
int row = sizeof(map)/sizeof(map[0]);
int col = sizeof(map[0])/ sizeof(map[0][0]);
/**
* @brief printMap
* @param map 需要打印的二维数组
* @param row 二维数组的行数
* @param col 二维数组的列数
*/
void printMap(char map[6][7] , int row, int col)
{
system("cls");
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
printf("%c", map[i][j]);
}
printf("\n");
}
}
// 1.定义二维数组保存迷宫地图
char map[6][7] = {
{'#', '#', '#', '#', '#', '#', '#'},
{'#', ' ', ' ', ' ', '#' ,' ', ' '},
{'#', 'R', ' ', '#', '#', ' ', '#'},
{'#', ' ', ' ', ' ', '#', ' ', '#'},
{'#', '#', ' ', ' ', ' ', ' ', '#'},
{'#', '#', '#', '#', '#', '#', '#'}
};
// 2.计算地图行数和列数
int row = sizeof(map)/sizeof(map[0]);
int col = sizeof(map[0])/ sizeof(map[0][0]);
// 3.输出地图
printMap(map, row, col);
// 4.定义变量记录人物位置
int pRow = 2;
int pCol = 1;
// 5.定义变量记录出口的位置
int endRow = 1;
int endCol = 6;
// 6.控制人物行走
while ('R' != map[endRow][endCol]) {
... ...
}
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
|---|---|---|---|---|---|---|---|
| char | short | int | long | float | double | if | else |
| return | do | while | for | switch | case | break | continue |
| default | goto | sizeof | auto | register | static | extern | unsigned |
| signed | typedef | struct | enum | union | void | const | volatile |
这些不用专门去记住,用多了就会了。在编译器里都是有特殊颜色的。我们用到时候会一个一个讲解这个些关键字怎么用,现在浏览下,有个印象就OK了
| fromNo22 | from#22 | my_Boolean | my-Boolean | 2ndObj | GUI | lnj |
| Mike2jack | 江哥 | _test | test!32 | haha(da)tt | jack_rose | jack&rose |
生活中无时无刻都在跟数据打交道
例如:人的体重、身高、收入、性别等数据等
在我们使用计算机的过程中，也会接触到各种各样的数据
例如: 文档数据、图片数据、视频数据等
静态的数据
动态的数据
既然硬盘的存储空间这么大，为何不把所有的应用程序加载到硬盘中去执行呢？
1 B(Byte字节) = 8 bit(位)
// 00000000 就是一个字节
// 111111111 也是一个字节
// 10101010 也是一个字节
// 任意8个0和1的组合都是一个字节
1 KB(KByte) = 1024 B
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB
整型常量
实型常量
字符常量
字符串常量
自定义常量
常量类型练习
| 123 | 1.1F | 1.1 | .3 | 'a' | "a" | "李南江" |
int a;
float b;
char ch;
int a,b,c;
int value;
value = 998; // 赋值
int value; value = 998; // 初始化int a = 10; int b = 4, c = 2;int a, b = 10; //部分初始化
int c, d, e;
c = d = e =0;
int i = 10;
i = 20; // 修改变量的值
int a = 10;
int b = a; // 相当于把a中存储的10拷贝了一份给b
int a = 10, c = 11;
printf("a=%d, c=%d", a, c);
double height = 1.75;
char blood = 'A';
printf("height=%.2f, 血型是%c", height, blood);
int main(){
int i = 998; // 作用域开始
return 0;// 作用域结束
}
int main(){
{
int i = 998; // 作用域开始
}// 作用域结束
printf("i = %d\n", i); // 不能使用
return 0;
}
int main(){
{
{
int i = 998;// 作用域开始
}// 作用域结束
printf("i = %d\n", i); // 不能使用
}
return 0;
}
int i = 666;
int main(){
printf("i = %d\n", i); // 可以使用
return 0;
}// 作用域结束
int call(){
printf("i = %d\n", i); // 可以使用
return 0;
}
int main(){
int i = 998; // 作用域开始
int i = 666; // 报错, 重复定义
return 0;
}// 作用域结束
int i = 666;
int i = 998; // 报错, 重复定义
int main(){
return 0;
}
int i = 666;
int main(){
int i = 998; // 不会报错
return 0;
}
int main(){
int i = 998; // 不会报错
return 0;
}
int call(){
int i = 666; // 不会报错
return 0;
}
| 类型 | 16位编译器 | 32位编译器 | 64位编译器 |
|---|---|---|---|
| char | 1 | 1 | 1 |
| int | 2 | 4 | 4 |
| float | 4 | 4 | 4 |
| double | 8 | 8 | 8 |
| short | 2 | 2 | 2 |
| long | 4 | 4 | 8 |
| long long | 8 | 8 | 8 |
| void* | 2 | 4 | 8 |
变量存储的过程
int main(){
int number;
int value;
number = 22;
value = 666;
}
#include <stdio.h>
int main(){
int number;
int value;
number = 22;
value = 666;
printf("&number = %p\n", &number); // 0060FEAC
printf("&value = %p\n", &value); // 0060FEA8
}
先不要着急, 刚开始接触C语言, 我先了解这么多就够了. 后面会再次更深入的讲解存储的各种细节。
printf("格式控制字符串",输出项列表 );printf("a = %d, b = %d",a, b);
%[标志][输出宽度][.精度][长度]类型printf("a = %类型", a);| 类型 | 含义 |
|---|---|
| d | 有符号10进制整型 |
| i | 有符号10进制整型 |
| u | 无符号10进制整型 |
| o | 无符号8进制整型 |
| x | 无符号16进制整型 |
| X | 无符号16进制整型 |
| f | 单、双精度浮点数(默认保留6位小数) |
| e / E | 以指数形式输出单、双精度浮点数 |
| g / G | 以最短输出宽度,输出单、双精度浮点数 |
| c | 字符 |
| s | 字符串 |
| p | 地址 |
#include <stdio.h>
int main(){
int a = 10;
int b = -10;
float c = 6.6f;
double d = 3.1415926;
double e = 10.10;
char f = 'a';
// 有符号整数(可以输出负数)
printf("a = %d\n", a); // 10
printf("a = %i\n", a); // 10
// 无符号整数(不可以输出负数)
printf("a = %u\n", a); // 10
printf("b = %u\n", b); // 429496786
// 无符号八进制整数(不可以输出负数)
printf("a = %o\n", a); // 12
printf("b = %o\n", b); // 37777777766
// 无符号十六进制整数(不可以输出负数)
printf("a = %x\n", a); // a
printf("b = %x\n", b); // fffffff6
// 无符号十六进制整数(不可以输出负数)
printf("a = %X\n", a); // A
printf("b = %X\n", b); // FFFFFFF6
// 单、双精度浮点数(默认保留6位小数)
printf("c = %f\n", c); // 6.600000
printf("d = %lf\n", d); // 3.141593
// 以指数形式输出单、双精度浮点数
printf("e = %e\n", e); // 1.010000e+001
printf("e = %E\n", e); // 1.010000E+001
// 以最短输出宽度,输出单、双精度浮点数
printf("e = %g\n", e); // 10.1
printf("e = %G\n", e); // 10.1
// 输出字符
printf("f = %c\n", f); // a
}
printf("a = %[宽度]类型", a);#include <stdio.h>
int main(){
// 实际位数小于指定宽度
int a = 1;
printf("a =|%d|\n", a); // |1|
printf("a =|%5d|\n", a); // | 1|
// 实际位数大于指定宽度
int b = 1234567;
printf("b =|%d|\n", b); // |1234567|
printf("b =|%5d|\n", b); // |1234567|
}
printf("a = %[标志][宽度]类型", a);| 标志 | 含义 |
|---|---|
| - | 左对齐, 默认右对齐 |
| + | 当输出值为正数时,在输出值前面加上一个+号, 默认不显示 |
| 0 | 右对齐时, 用0填充宽度.(默认用空格填充) |
| 空格 | 输出值为正数时,在输出值前面加上空格, 为负数时加上负号 |
| # | 对c、s、d、u类型无影响 |
| # | 对o类型, 在输出时加前缀o |
| # | 对x类型,在输出时加前缀0x |
#include <stdio.h>
int main(){
int a = 1;
int b = -1;
// -号标志
printf("a =|%d|\n", a); // |1|
printf("a =|%5d|\n", a); // | 1|
printf("a =|%-5d|\n", a);// |1 |
// +号标志
printf("a =|%d|\n", a); // |1|
printf("a =|%+d|\n", a);// |+1|
printf("b =|%d|\n", b); // |-1|
printf("b =|%+d|\n", b);// |-1|
// 0标志
printf("a =|%5d|\n", a); // | 1|
printf("a =|%05d|\n", a); // |00001|
// 空格标志
printf("a =|% d|\n", a); // | 1|
printf("b =|% d|\n", b); // |-1|
// #号
int c = 10;
printf("c = %o\n", c); // 12
printf("c = %#o\n", c); // 012
printf("c = %x\n", c); // a
printf("c = %#x\n", c); // 0xa
}
printf("a = %[精度]类型", a);#include <stdio.h>
int main(){
double a = 3.1415926;
printf("a = %.2f\n", a); // 3.14
}
printf("a = %.*f", a);#include <stdio.h>
int main(){
double a = 3.1415926;
printf("a = %.*f", 2, a); // 3.14
}
#include <stdio.h>
int main(){
// 1234.567871093750000
float a = 1234.567890123456789;
// 1234.567890123456900
double b = 1234.567890123456789;
printf("a = %.15f\n", a); // 前8位数字是准确的, 后面的都不准确
printf("b = %.15f\n", b); // 前16位数字是准确的, 后面的都不准确
}
printf("a = %[长度]类型", a);| 长度 | 修饰类型 | 含义 |
|---|---|---|
| hh | d、i、o、u、x | 输出char |
| h | d、i、o、u、x | 输出 short int |
| l | d、i、o、u、x | 输出 long int |
| ll | d、i、o、u、x | 输出 long long int |
#include <stdio.h>
int main(){
char a = 'a';
short int b = 123;
int c = 123;
long int d = 123;
long long int e = 123;
printf("a = %hhd\n", a); // 97
printf("b = %hd\n", b); // 123
printf("c = %d\n", c); // 123
printf("d = %ld\n", d); // 123
printf("e = %lld\n", e); // 123
}
printf("%f%%", 3.1415);#include <stdio.h>
int main(){
printf("%f%%", 3.1415); // 输出结果3.1415%
}
scanf("格式控制字符串", 地址列表);scanf("%d", &num);
#include <stdio.h>
int main(){
int number;
scanf("%d", &number); // 接收一个整数
printf("number = %d\n", number);
}
#include <stdio.h>
int main(){
float num;
// 例如:输入 Tab 空格 回车 回车 Tab 空格 3.14 , 得到的结果还是3.14
scanf("%f", &num);
printf("num = %f\n", num);
}
#include <stdio.h>
int main(){
int number;
// 用户必须输入number = 数字 , 否则会得到一个意外的值
scanf("number = %d", &number);
printf("number = %d\n", number);
}
#include <stdio.h>
int main(){
int number;
scanf("%d", &number);
printf("number = %d\n", number);
int value;
scanf("%d", &value);
printf("value = %d\n", value);
}
#include <stdio.h>
int main(){
int number;
int value;
// 可以输入 数字 空格 数字, 或者 数字 回车 数字
scanf("%d%d", &number, &value);
printf("number = %d\n", number);
printf("value = %d\n", value);
}
#include <stdio.h>
int main(){
int number;
int value;
// 输入 数字,数字 即可
scanf("%d,%d", &number, &value);
printf("number = %d\n", number);
printf("value = %d\n", value);
}
#include <stdio.h>
int main(){
int number;
// 输入完毕之后按下回车无法结束输入
scanf("%d\n", &number);
printf("number = %d\n", number);
}
#include <stdio.h>
int main(){
int num1;
int num2;
char ch1;
scanf("%d%c%d", &num1, &ch1, &num2);
printf("num1 = %d, ch1 = %c, num2 = %d\n", num1, ch1, num2);
char ch2;
int num3;
scanf("%c%d",&ch2, &num3);
printf("ch2 = %c, num3 = %d\n", ch2, num3);
}
fflush(stdin);setbuf(stdin, NULL);#include <stdio.h>
int main(){
int num1;
int num2;
char ch1;
scanf("%d%c%d", &num1, &ch1, &num2);
printf("num1 = %d, ch1 = %c, num2 = %d\n", num1, ch1, num2);
//fflush(stdin); // 清空输入缓存区
setbuf(stdin, NULL); // 清空输入缓存区
char ch2;
int num3;
scanf("%c%d",&ch2, &num3);
printf("ch2 = %c, num3 = %d\n", ch2, num3);
}
#include <stdio.h>
int main(){
char ch = 'a';
putchar(ch); // 输出a
}
#include <stdio.h>
int main(){
char ch;
ch = getchar();// 获取一个字符
printf("ch = %c\n", ch);
}
和数学中的运算符一样, C语言中的运算符是告诉程序执行特定算术或逻辑操作的符号
什么是表达式
| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 3 | 乘法运算符 | * | 双目运算符,具有左结合性 |
| 3 | 除法运算符 | / | 双目运算符,具有左结合性 |
| 3 | 求余运算符 (模运算符) | % | 双目运算符,具有左结合性 |
| 4 | 加法运算符 | + | 双目运算符,具有左结合性 |
| 4 | 减法运算符 | - | 双目运算符,具有左结合性 |
#include <stdio.h>
int main(){
int a = 10;
int b = 5;
// 加法
int result = a + b;
printf("%i\n", result); // 15
// 减法
result = a - b;
printf("%i\n", result); // 5
// 乘法
result = a * b;
printf("%i\n", result); // 50
// 除法
result = a / b;
printf("%i\n", result); // 2
// 算术运算符的结合性和优先级
// 结合性: 左结合性, 从左至右
int c = 50;
result = a + b + c; // 15 + c; 65;
printf("%i\n", result);
// 优先级: * / % 大于 + -
result = a + b * c; // a + 250; 260;
printf("%i\n", result);
}
#include <stdio.h>
int main(){
// 整数除以整数, 结果还是整数
printf("%i\n", 10 / 3); // 3
// 参与运算的任何一个数是小数, 结果就是小数
printf("%f\n", 10 / 3.0); // 3.333333
}
#include <stdio.h>
int main(){
// 10 / 3 商等于3, 余1
int result = 10 % 3;
printf("%i\n", result); // 1
// 左边小于右边, 那么结果就是左边
result = 2 % 10;
printf("%i\n", result); // 2
// 被除数是正数结果就是正数,被除数是负数结果就是负数
result = 10 % 3;
printf("%i\n", result); // 1
result = -10 % 3;
printf("%i\n", result); // -1
result = 10 % -3;
printf("%i\n", result); // 1
}
| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 14 | 赋值运算符 | = | 双目运算符,具有右结合性 |
| 14 | 除后赋值运算符 | /= | 双目运算符,具有右结合性 |
| 14 | 乘后赋值运算符 (模运算符) | *= | 双目运算符,具有右结合性 |
| 14 | 取模后赋值运算符 | %= | 双目运算符,具有右结合性 |
| 14 | 加后赋值运算符 | += | 双目运算符,具有右结合性 |
| 14 | 减后赋值运算符 | -= | 双目运算符,具有右结合性 |
#include <stdio.h>
int main(){
// 简单的赋值运算符 =
// 会将=右边的值赋值给左边
int a = 10;
printf("a = %i\n", a); // 10
}
#include <stdio.h>
int main(){
// 复合赋值运算符 += -= *= /= %=
// 将变量中的值取出之后进行对应的操作, 操作完毕之后再重新赋值给变量
int num1 = 10;
// num1 = num1 + 1; num1 = 10 + 1; num1 = 11;
num1 += 1;
printf("num1 = %i\n", num1); // 11
int num2 = 10;
// num2 = num2 - 1; num2 = 10 - 1; num2 = 9;
num2 -= 1;
printf("num2 = %i\n", num2); // 9
int num3 = 10;
// num3 = num3 * 2; num3 = 10 * 2; num3 = 20;
num3 *= 2;
printf("num3 = %i\n", num3); // 20
int num4 = 10;
// num4 = num4 / 2; num4 = 10 / 2; num4 = 5;
num4 /= 2;
printf("num4 = %i\n", num4); // 5
int num5 = 10;
// num5 = num5 % 3; num5 = 10 % 3; num5 = 1;
num5 %= 3;
printf("num5 = %i\n", num5); // 1
}
#include <stdio.h>
int main(){
int number = 10;
// 赋值运算符优先级是14, 普通运算符优先级是3和4, 所以先计算普通运算符
// 普通运算符中乘法优先级是3, 加法是4, 所以先计算乘法
// number += 1 + 25; number += 26; number = number + 26; number = 36;
number += 1 + 5 * 5;
printf("number = %i\n", number); // 36
}
| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 2 | 自增运算符(在后) | i++ | 单目运算符,具有左结合性 |
| 2 | 自增运算符(在前) | ++i | 单目运算符,具有右结合性 |
| 2 | 自减运算符(在后) | i-- | 单目运算符,具有左结合性 |
| 2 | 自减运算符(在前) | --i | 单目运算符,具有右结合性 |
#include <stdio.h>
int main(){
int number = 10;
number++;
printf("number = %i\n", number); // 11
++number;
printf("number = %i\n", number); // 12
}
#include <stdio.h>
int main(){
int number = 10;
// ++在后, 先参与表达式运算, 再自增
// 表达式运算时为: 3 + 10;
int result = 3 + number++;
printf("result = %i\n", result); // 13
printf("number = %i\n", number); // 11
}
#include <stdio.h>
int main(){
int number = 10;
// ++在前, 先自增, 再参与表达式运算
// 表达式运算时为: 3 + 11;
int result = 3 + ++number;
printf("result = %i\n", result); // 14
printf("number = %i\n", number); // 11
}
#include <stdio.h>
int main(){
int number = 10;
// --在后, 先参与表达式运算, 再自减
// 表达式运算时为: 10 + 3;
int result = number-- + 3;
printf("result = %i\n", result); // 13
printf("number = %i\n", number); // 9
}
#include <stdio.h>
int main(){
int number = 10;
// --在前, 先自减, 再参与表达式运算
// 表达式运算时为: 9 + 3;
int result = --number + 3;
printf("result = %i\n", result); // 12
printf("number = %i\n", number); // 9
}
++(a+b); 5++;int i = 10;
int b = i++; // 不推荐
或者
int b = ++i; // 不推荐
或者
int a = 10;
int b = ++a + a++; // 不推荐
int i = 10;
int b = i; // 推荐
i++;
或者;
i++;
int b = i; // 推荐
或者
int a = 10;
++a;
int b = a + a; // 推荐
a++;
同一个表达式中同一个变量自增或自减后如何运算, 不同编译器得到结果也不同, 在企业开发中千万不要这样写 int a = 1;
// 下列代码利用Qt运行时6, 利用Xcode运行是5
// 但是无论如何, 最终a的值都是3
// 在C语言中这种代码没有意义, 不用深究也不要这样写
// 特点: 参与运算的是同一个变量, 参与运算时都做了自增自减操作, 并且在同一个表达式中
int b = ++a + ++a;
printf("b = %i\n", b);
sizeof可以用来计算一个变量或常量、数据类型所占的内存字节数
sizeof的几种形式
sizeof(float);如果是数据类型不能省略括号sizeof 10;char c = 'a'; sizeof c;sizeof(10);char c = 'a'; sizeof(c);sizeof面试题:
#include <stdio.h>
int main(){
int a = 10;
double b = 3.14;
// 由于sizeof的优先级比+号高, 所以会先计算sizeof(a);
// a是int类型, 所以占4个字节得到结果4
// 然后再利用计算结果和b相加, 4 + 3.14 = 7.14
double res = sizeof a+b;
printf("res = %lf\n", res); // 7.14
}
表达式1，表达式2，… …，表达式n;int result = a+1,b=3*4;#include <stdio.h>
int main(){
int a = 10, b = 20, c;
// ()优先级高于逗号运算符和赋值运算符, 所以先计算()中的内容
// c = (11, 21);
// ()中是一个逗号表达式, 结果是最后一个表达式的值, 所以计算结果为21
// 将逗号表达式的结果赋值给c, 所以c的结果是21
c = (a + 1, b + 1);
printf("c = %i\n", c); // 21
}
| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 6 | 大于运算符 | > | 双目运算符,具有左结合性 |
| 6 | 小于运算符 | < | 双目运算符,具有左结合性 |
| 6 | 大于等于运算符 | >= | 双目运算符,具有左结合性 |
| 6 | 小于等于运算符 | <= | 双目运算符,具有左结合性 |
| 7 | 等于运算符 | == | 双目运算符,具有左结合性 |
| 7 | 不等于运算符 | != | 双目运算符,具有左结合性 |
#include <stdio.h>
int main(){
int result = 10 > 5;
printf("result = %i\n", result); // 1
result = 5 < 10;
printf("result = %i\n", result); // 1
result = 5 > 10;
printf("result = %i\n", result); // 0
result = 10 >= 10;
printf("result = %i\n", result); // 1
result = 10 <= 10;
printf("result = %i\n", result); // 1
result = 10 == 10;
printf("result = %i\n", result); // 1
result = 10 != 9;
printf("result = %i\n", result); // 1
}
#include <stdio.h>
int main(){
// == 优先级 小于 >, 所以先计算>
// result = 10 == 1; result = 0;
int result = 10 == 5 > 3;
printf("result = %i\n", result); // 0
}
#include <stdio.h>
int main(){
// == 和 != 优先级一样, 所以按照结合性
// 关系运算符是左结合性, 所以从左至右计算
// result = 0 != 3; result = 1;
int result = 10 == 5 != 3;
printf("result = %i\n", result); // 1
}
int result1 = 3 > 4 + 7
int result2 = (3>4) + 7
int result3 = 5 != 4 + 2 * 7 > 3 == 10
#include <stdio.h>
int main(){
float a = 0.1;
float b = a * 10 + 0.00000000001;
double c = 1.0 + + 0.00000000001;
printf("b = %f\n", b);
printf("c = %f\n", c);
int result = b == c;
printf("result = %i\n", result); // 0
}
| 优先级 | 名称 | 符号 | 说明 |
|---|---|---|---|
| 2 | 逻辑非运算符 | ! | 单目运算符,具有右结合性 |
| 11 | 逻辑与运算符 | && | 双目运算符,具有左结合性 |
| 12 | 逻辑或运算符 | \|\| | 双目运算符,具有左结合性 |
! 条件A;#include <stdio.h>
int main(){
// ()优先级高, 先计算()里面的内容
// 10==10为真, 所以result = !(1);
// !代表真变假, 假变真,所以结果是假0
int result = !(10 == 10);
printf("result = %i\n", result); // 0
}
条件A && 条件B;#include <stdio.h>
int main(){
// 真 && 真
int result = (10 == 10) && (5 != 1);
printf("result = %i\n", result); // 1
// 假 && 真
result = (10 == 9) && (5 != 1);
printf("result = %i\n", result); // 0
// 真 && 假
result = (10 == 10) && (5 != 5);
printf("result = %i\n", result); // 0
// 假 && 假
result = (10 == 9) && (5 != 5);
printf("result = %i\n", result); // 0
}
#include <stdio.h>
int main(){
int a = 10;
int b = 20;
// 逻辑与, 前面为假, 不会继续执行后面
int result = (a == 9) && (++b);
printf("result = %i\n", result); // 1
printf("b = %i\n", b); // 20
}
条件A || 条件B;#include <stdio.h>
int main(){
// 真 || 真
int result = (10 == 10) || (5 != 1);
printf("result = %i\n", result); // 1
// 假 || 真
result = (10 == 9) || (5 != 1);
printf("result = %i\n", result); // 1
// 真 || 假
result = (10 == 10) || (5 != 5);
printf("result = %i\n", result); // 1
// 假 || 假
result = (10 == 9) || (5 != 5);
printf("result = %i\n", result); // 0
}
#include <stdio.h>
int main(){
int a = 10;
int b = 20;
// 逻辑或, 前面为真, 不会继续执行后面
int result = (a == 10) || (++b);
printf("result = %i\n", result); // 1
printf("b = %i\n", b); // 20
}
int result = 3>5 || 2<4 && 6<1;
表达式1？表达式2(结果A)：表达式3(结果B)考试及格 ? 及格 : 不及格;
示例:
int a = 10;
int b = 20;
int max = (a > b) ? a : b;
printf("max = %d", max);
输出结果: 20
等价于:
int a = 10;
int b = 20;
int max = 0;
if(a>b){
max=a;
}else {
max=b;
}
printf("max = %d", max);
#include <stdio.h>
int main(){
int a = 10;
int b = 5;
// 先计算 a > b
// 然后再根据计算结果判定返回a还是b
// 相当于int max= (a>b) ? a : b;
int max= a>b ? a : b;
printf("max = %i\n", max); // 10
}
#include <stdio.h>
int main(){
int a = 10;
int b = 5;
int c = 20;
int d = 10;
// 结合性是从右至左, 所以会先计算:后面的内容
// int res = a>b?a:(c>d?c:d);
// int res = a>b?a:(20>10?20:10);
// int res = a>b?a:(20);
// 然后再计算最终的结果
// int res = 10>5?10:(20);
// int res = 10;
int res = a>b?a:c>d?c:d;
printf("res = %i\n", res);
}
| 强制类型转换(显示转换) | 自动类型转换(隐式转换) |
|---|---|
| (需要转换的类型)(表达式) | 1.算数转换 2.赋值转换 |
// 将double转换为int
int a = (int)10.5;
// 当前表达式用1.0占用8个字节, 2占用4个字节
// 所以会先将整数类型2转换为double类型之后再计算
double b = 1.0 / 2;
// 赋值时左边是什么类型,就会自动将右边转换为什么类型再保存
int a = 10.6;
// 结果为0, 因为参与运算的都是整型
double a = (double)(1 / 2);
// 结果为0.5, 因为1被强制转换为了double类型, 2也会被自动提升为double类型
double b = (double)1 / 2;
#include <stdio.h>
int main(){
double d = 3.14;
int num = (int)d;
printf("num = %i\n", num); // 3
printf("d = %lf\n", d); // 3.140000
}
交换前
int a = 10; int b = 20;
交换后
int a = 20; int b = 10;
if(表达式) {
语句块1;
}
后续语句;
if(age >= 18) {
printf("开网卡\n");
}
printf("买烟\n");
if(表达式){
语句块1;
}else{
语句块2;
}
后续语句;
if(age > 18){
printf("开网卡\n");
}else{
printf("喊家长来开\n");
}
printf("买烟\n");
if(表达式1) {
语句块1;
}else if(表达式2){
语句块2;
}else if(表达式3){
语句块3;
}else{
语句块4;
}
后续语句;
if(age>40){
printf("给房卡");
}else if(age>25){
printf("给名片");
}else if(age>18){
printf("给网卡");
}else{
printf("给好人卡");
}
printf("买烟\n");
if(表达式1){
语句块1;
if(表达式2){
语句块2;
}
}else{
if(表达式3){
语句块3;
}else{
语句块4;
}
}
#include <stdio.h>
int main(){
if(0){
printf("执行了if");
}else{
printf("执行了else"); // 被执行
}
}
// 极其不推荐写法
int age = 17;
if (age >= 18)
printf("开网卡\n");
else
printf("喊家长来开\n");
#include <stdio.h>
int main(){
if(0)
if(1)
printf("A\n");
else // 和if(1)匹配
printf("B\n");
else // 和if(0)匹配, 因为if(1)已经被匹配过了
if (1)
printf("C\n"); // 输出C
else // 和if(1)匹配
printf("D\n");
}
#include <stdio.h>
int main(){
if(1)
int number = 10; // 系统会报错
printf("number = %i\n", number);
}
#include <stdio.h>
int main(){
if(0){
int number = 10;
}else
int value = 20; // 系统会报错
printf("value = %i\n", value);
}
// 因为if(10 > 2)后面有一个分号, 所以系统会认为if省略了大括号
// if省略大括号时只能管控紧随其后的那条语句, 所以只能管控分号
if(10 > 2);
{
printf("10 > 2");
}
// 输出结果: 10 > 2
#include <stdio.h>
int main(){
int a = 8;
// if(a = 10){// 错误写法, 但不会报错
if (10 == a){
printf("a的值是10\n");
}else{
printf("a的值不是10\n");
}
}
if练习
实现石头剪刀布
剪刀石头布游戏:
1)定义游戏规则
剪刀 干掉 布
石头 干掉 剪刀
布 干掉石头
2)显示玩家开始猜拳
3)接收玩家输入的内容
4)让电脑随机产生一种拳
5)判断比较
(1)玩家赢的情况(显示玩家赢了)
(2)电脑赢的情况(显示电脑赢了)
(3)平局(显示平局)
switch(表达式){
case 常量表达式1:
语句1;
break;
case 常量表达式2:
语句2;
break;
case 常量表达式n:
语句n;
break;
default:
语句n+1;
break;
}
#include <stdio.h>
int main() {
int num = 3;
switch(num){
case 1:
printf("星期一\n");
break;
case 2:
printf("星期二\n");
break;
case 3:
printf("星期三\n");
break;
case 4:
printf("星期四\n");
break;
case 5:
printf("星期五\n");
break;
case 6:
printf("星期六\n");
break;
case 7:
printf("星期日\n");
break;
default:
printf("回火星去\n");
break;
}
}
#include <stdio.h>
int main() {
switch(1.1){ // 报错
case 1:
printf("星期一\n");
break;
case 2:
printf("星期二\n");
break;
default:
printf("回火星去\n");
break;
}
}
#include <stdio.h>
int main() {
int num = 3;
switch(1){
case 1:
printf("星期一\n");
break;
case 'a':
printf("星期二\n");
break;
case num: // 报错
printf("星期三\n");
break;
case 4.0: // 报错
printf("星期四\n");
break;
default:
printf("回火星去\n");
break;
}
}
#include <stdio.h>
int main() {
switch(1){
case 1: // 报错
printf("星期一\n");
break;
case 1: // 报错
printf("星期一\n");
break;
default:
printf("回火星去\n");
break;
}
}
#include <stdio.h>
int main() {
switch(1){
case 1:{
int num = 10;
printf("num = %i\n", num);
printf("星期一\n");
break;
}
case 2:
printf("星期一\n");
break;
default:
printf("回火星去\n");
break;
}
}
#include <stdio.h>
int main() {
int num = 2;
switch(num){
case 1:
printf("星期一\n");
break;
case 2:
printf("星期二\n"); // 被输出
case 3:
printf("星期三\n"); // 被输出
default:
printf("回火星去\n"); // 被输出
break;
}
}
#include <stdio.h>
int main() {
switch(1){
case 1:
printf("星期一\n");
break;
case 2:
printf("星期一\n");
break;
}
}
#include <stdio.h>
int main() {
switch(3){
case 1:
printf("星期一\n");
break;
default:
printf("Other,,,\n");
break;
case 2:
printf("星期一\n");
break;
}
}
#include <stdio.h>
int main() {
int a = -1;
scanf("%d", &a);
if(a > 100){
printf("用户输入的数据大于100");
}else{
printf("用户输入的数据不大于100");
}
}
#include <stdio.h>
int main() {
int a = -1;
scanf("%d", &a);
// 挺(T)萌(M)的(D)搞不定啊
switch (a) {
case 101:
case 102:
case 103:
case 104:
case 105:
printf("大于\n");
break;
default:
printf("不大于\n");
break;
}
}
要求用户输入一个分数，根据输入的分数输出对应的等级
A 90～100
B 80～89
C 70～79
D 60～69
E 0～59
while ( 循环控制条件 ) {
循环体中的语句;
能够让循环结束的语句;
....
}
构成循环结构的几个条件
示例:
int count = 0;
while (count < 3) { // 循环控制条件
printf("发射子弹~哔哔哔哔\n"); // 需要反复执行的语句
count++; // 能够让循环结束的语句
}
#include <stdio.h>
int main(){
int count = 4;
// 1.判断循环控制条件是否为真,此时为假所以跳过循环语句
while (count < 3) {
printf("发射子弹~哔哔哔哔\n");
count++;
}
// 2.执行循环语句后面的代码, 打印"循环执行完毕"
printf("循环执行完毕\n");
}
#include <stdio.h>
int main(){
int count = 0;
// 1.判断循环控制条件是否为真,此时0 < 3为真
// 4.再次判断循环控制条件是否为真,此时1 < 3为真
// 7.再次判断循环控制条件是否为真,此时2 < 3为真
// 10.再次判断循环控制条件是否为真,此时3 < 3为假, 跳过循环语句
while (count < 3) {
// 2.执行循环体中的代码, 打印"发子弹"
// 5.执行循环体中的代码, 打印"发子弹"
// 8.执行循环体中的代码, 打印"发子弹"
printf("发射子弹~哔哔哔哔\n");
// 3.执行"能够让循环结束的语句" count = 1
// 6.执行"能够让循环结束的语句" count = 2
// 9.执行"能够让循环结束的语句" count = 3
count++;
}
// 11.执行循环语句后面的代码, 打印"循环执行完毕"
printf("循环执行完毕\n");
}
#include <stdio.h>
int main(){
while (1) { // 死循环
printf("发射子弹~哔哔哔哔\n");
// 没有能够让循环结束的语句
}
}
#include <stdio.h>
int main(){
while (1) // 死循环
printf("发射子弹~哔哔哔哔\n");
// 没有能够让循环结束的语句
}
#include <stdio.h>
int main(){
while (1) // 死循环
int num = 10; // 报错
// 没有能够让循环结束的语句
}
#include <stdio.h>
int main(){
int count = 0;
while (count < 3);{ // 死循环
printf("发射子弹~哔哔哔哔\n");
count++;
}
}
// 死循环一般在操作系统级别的应用程序会比较多, 日常开发中很少用
while (1);
do {
循环体中的语句;
能够让循环结束的语句;
....
} while (循环控制条件 );
int count = 0;
do {
printf("发射子弹~哔哔哔哔\n");
count++;
}while(count < 10);
do-while循环执行流程
应用场景
#include<stdio.h>
int main()
{
int num = -1;
do{
printf("请输入密码,验证您的身份\n");
scanf("%d", &num);
}while(123456 != num);
printf("主人,您终于回来了\n");
}
for(初始化表达式；循环条件表达式；循环后的操作表达式) {
循环体中的语句;
}
for(int i = 0; i < 10; i++){
printf("发射子弹~哔哔哔哔\n");
}
for循环执行流程
for循环注意点:
for(;;);for和while应用场景
int count = 0; // 初始化表达式
while (count < 10) { // 条件表达式
printf("发射子弹~哔哔哔哔 %i\n", count);
count++; // 循环后增量表达式
}
// 如果初始化表达式的值, 需要在循环之后使用, 那么就用while
printf("count = %i\n", count);
// 注意: 在for循环初始化表达式中定义的变量, 只能在for循环后面的{}中访问
// 所以: 如果初始化表达式的值, 不需要在循环之后使用, 那么就用for
// 因为如果初始化表达式的值, 在循环之后就不需要使用了 , 那么用while会导致性能问题
for (int count = 0; count < 10; count++) {
printf("发射子弹~哔哔哔哔 %i\n", count);
}
// printf("count = %i\n", count);
// 如果需要使用初始化表达式的值, 也可以将初始化表达式写到外面
int count = 0;
for (; count < 10; count++) {
printf("发射子弹~哔哔哔哔\n", count);
}
printf("count = %i\n", count);
if(1) {
break; // 会报错
}
while(1) {
while(2) {
break;// 只对while2有效, 不会影响while1
}
printf("while1循环体\n");
}
while(2){
break;
printf("打我啊!");// 执行不到
}
if(1) {
continue; // 会报错
}
#include <stdio.h>
int main(){
int num = 0;
// loop:是定义的标记
loop:if(num < 10){
printf("num = %d\n", num);
num++;
// goto loop代表跳转到标记的位置
goto loop;
}
}
#include <stdio.h>
int main(){
while (1) {
while(2){
goto lnj;
}
}
lnj:printf("跳过了所有循环");
}
Qt Creator Keyboard Shortcuts(Documentation): http://doc.qt.io/qtcreator/creator-keyboard-shortcuts.html
[2]Qt Creator Keyboard Shortcuts(Wiki): http://wiki.qt.io/Qt_Creator_Keyboard_Shortcuts
while(条件表达式) {
while循环结构 or dowhile循环结构 or for循环结构
}
for(初始化表达式；循环条件表达式；循环后的操作表达式) {
while循环结构 or dowhile循环结构 or for循环结构
}
do {
while循环结构 or dowhile循环结构 or for循环结构
} while (循环控制条件 );
for (row=0; row<100; row++) {
// 低效率：长循环在最外层
for ( col=0; col<5; col++ ) {
sum = sum + a[row][col];
}
}
for (col=0; col<5; col++ ) {
// 高效率：长循环在最内层
for (row=0; row<100; row++) {
sum = sum + a[row][col];
}
}
好友列表1
好友1
好友2
好友列表2
好友1
好友2
好友列表3
好友1
好友2
for (int i = 0; i < 4; i++) {
printf("好友列表%d\n", i+1);
for (int j = 0; j < 4; j++) {
printf(" 角色%d\n", j);
}
}
************
// 3行4列// 外循环控制行数for (int i = 0; i < 3; i++) {// 内循环控制列数 for (int j = 0; j < 4; j++) { printf("*"); } printf("\n");}
***************
/*最多打印5行最多打印5列每一行和每一列关系是什么? 列数<=行数*/for(int i = 0; i< 5; i++) { for(int j = 0; j <= i; j++) { printf("*"); } printf("\n");}
***************
for(int i = 0; i< 5; i++) { for(int j = i; j < 5; j++) { printf("*"); } printf("\n");}
112123
for (int i = 0; i < 3; i++) { for (int j = 0; j <= i; j++) { printf("%d", j+1); } printf("\n");}
122333
for (int i = 1; i <= 3; i++) { for (int j = 1; j <= i; j++) { printf("%d", i); } printf("\n");}
--*-********
for (int i = 0; i <= 5; i++) { for (int j = 0; j < 5 - i; j++) { printf("-"); } for (int m = 0; m < 2*i+1; m++) { printf("*"); } printf("\n");}
1 * 1 = 11 * 2 = 2 2 * 2 = 41 * 3 = 3 2 * 3 = 6 3 * 3 = 9
for (int i = 1; i <= 9; i++) { for (int j = 1; j <= i; j++) { printf("%d * %d = %d \t", j, i, (j * i)); } printf("\n");}
返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，…) { 函数体; 返回值;}
int main(){ printf("hello world\n"); retrun 0;}
没有返回值时return可以省略
格式:
void 函数名() { 函数体;}
示例:
// 1.没有返回值/没有形参// 如果一个函数不需要返回任何数据给调用者, 那么返回值类型就是voidvoid printRose() { printf(" {@}\n"); printf(" |\n"); printf(" \\|/\n"); // 注意: \是一个特殊的符号(转意字符), 想输出\必须写两个斜线 printf(" |\n"); // 如果函数不需要返回数据给调用者, 那么函数中的return可以不写}
格式:
返回值类型 函数名() { 函数体; return 值;}
示例:
int getMax() { printf("请输入两个整数, 以逗号隔开, 以回车结束\n"); int number1, number2; scanf("%i,%i", &number1, &number2); int max = number1 > number2 ? number1 : number2; return max;}
形式参数表列表的格式: 类型 变量名,类型 变量2,......
格式:
void 函数名(参数类型 形式参数1，参数类型 形式参数2，…) { 函数体;}
示例:
void printMax(int value1, int value2) { int max = value1 > value2 ? value1 : value2; printf("max = %i\n", max);}
格式:
返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，…) { 函数体; return 0;}
示例:
int printMax(int value1, int value2) { int max = value1 > value2 ? value1 : value2; return max;}
函数定义注意
函数名称不能相同
void test() {}void test() { // 报错}
int max(int number1, int number2) // 形式参数{ return number1 > number2 ? number1 : number2;}
int main() { int num = 99; // 88, num, 22+44均能得到一个确定的值, 所以都可以作为实参 max(88, num, 22+44); // 实际参数 return 0;}
调用函数时传递的实参个数必须和函数的形参个数必须保持一致
int max(int number1, int number2) { // 形式参数 return number1 > number2 ? number1 : number2;}int main() { // 函数需要2个形参, 但是我们只传递了一个实参, 所以报错 max(88); // 实际参数 return 0;}
形参实参类型不一致, 会自动转换为形参类型
void change(double number1, double number2) {// 形式参数 // 输出结果: 10.000000, 20.000000 // 自动将实参转换为double类型后保存 printf("number1 = %f, number2 = %f", number1, number2);}int main() { change(10, 20); return 0;}
当使用基本数据类型（char、int、float等）作为实参时，实参和形参之间只是值传递，修改形参的值并不影响到实参函数可以没有形参
void change(int number1, int number2) { // 形式参数
number1 = 250; // 不会影响实参
number2 = 222;
}
int main() {
int a = 88;
int b = 99;
change(a, b);
printf("a = %d, b = %d", a, b); // 输出结果: 88, 99
return 0;
}
如果没有写返回值类型，默认是int
max(int number1, int number2) {// 形式参数
return number1 > number2 ? number1 : number2;
}
函数返回值的类型和return实际返回的值类型应保持一致。如果两者不一致,则以返回值类型为准,自动进行类型转换
int height() {
return 3.14;
}
int main() {
double temp = height();
printf("%lf", temp);// 输出结果: 3.000000
}
一个函数内部可以多次使用return语句，但是return语句后面的代码就不再被执行
int max(int number1, int number2) {// 形式参数
return number1 > number2 ? number1 : number2;
printf("执行不到"); // 执行不到
return 250; // 执行不到
}
int max( int a, int b );int max( int, int );// 函数声明
void getMax(int v1, int v2);
int main(int argc, const char * argv[]) {
getMax(10, 20); // 调用函数
return 0;
}
// 函数实现
void getMax(int v1, int v2) {
int max = v1 > v2 ? v1 : v2;
printf("max = %i\n", max);
}
函数的实现不能重复, 而函数的声明可以重复
// 函数声明void getMax(int v1, int v2);void getMax(int v1, int v2);void getMax(int v1, int v2); // 不会报错int main(int argc, const char * argv[]) { getMax(10, 20); // 调用函数 return 0;}// 函数实现void getMax(int v1, int v2) { int max = v1 > v2 ? v1 : v2; printf("max = %i\n", max);}
函数声明可以写在函数外面,也可以写在函数里面, 只要在调用之前被声明即可
int main(int argc, const char * argv[]) { void getMax(int v1, int v2); // 函数声明, 不会报错 getMax(10, 20); // 调用函数 return 0;}// 函数实现void getMax(int v1, int v2) { int max = v1 > v2 ? v1 : v2; printf("max = %i\n", max);}
当被调函数的函数定义出现在主调函数之前时,在主调函数中也可以不对被调函数再作声明
// 函数实现void getMax(int v1, int v2) { int max = v1 > v2 ? v1 : v2; printf("max = %i\n", max);}int main(int argc, const char * argv[]) { getMax(10, 20); // 调用函数 return 0;}
如果被调函数的返回值是整型时,可以不对被调函数作说明,而直接调用
int main(int argc, const char * argv[]) { int res = getMin(5, 3); // 不会报错 printf("result = %d\n", res ); return 0;}int getMin(int num1, int num2) {// 返回int, 不用声明 return num1 < num2 ? num1 : num2;}
一个函数在它的函数体内调用它自身称为递归调用
void function(int x){ function(x);}
void getNumber(){ int number = -1; while (number < 0) { printf("请输入一个正数\n"); scanf("%d", &number); } printf("number = %d\n", number);}
void getNumber2(){ int number = -1; printf("请输入一个正数abc\n"); scanf("%d", &number); if (number < 0) {// 负数 getNumber2(); }else{// 正数 printf("number = %d\n", number); }}
1.用不同进制表示如下有多少个方格
2.判断下列数字是否合理
00011 0x001 0x7h4 10.98 0986 .089-109
+178 0b325 0b0010 0xffdc 96f 96.0f 96.oF -.003
每一位二进制进制位的值 * 2的当前索引次幂; 再将所有位求出的值相加
例如: 将二进制01100100转换为十进制
01100100
索引从右至左, 从零开始
第0位: 0 * 2^0 = 0;
第1位: 0 * 2^1 = 0;
第2位: 1 * 2^2 = 4;
第3位: 0 * 2^3 = 0;
第4位: 0 * 2^4 = 0;
第5位: 1 * 2^5 = 32;
第6位: 1 * 2^6 = 64;
第7位: 0 * 2^7 = 0;
最终结果为: 0 + 0 + 4 + 0 + 0 + 32 + 64 + 0 = 100
三个二进制位代表一个八进制位, 因为3个二进制位的最大值是7，而八进制是逢8进1
例如: 将二进制01100100转换为八进制数
从右至左每3位划分为8进制的1位, 不够前面补0001 100 100第0位: 100 等于十进制 4第1位: 100 等于十进制 4第2位: 001 等于十进制 1最终结果: 144就是转换为8进制的值
四个二进制位代表一个十六进制位，因为4个二进制位的最大值是15，而十六进制是逢16进1
例如: 将二进制01100100转换为十六进制数
从右至左每4位划分为16进制的1位, 不够前面补00110 0100第0位: 0100 等于十进制 4第1位: 0110 等于十进制 6最终结果: 64就是转换为16进制的值
系数 * 基数 ^ 索引 之和
十进制 --> 十进制 12345 = 10000 + 2000 + 300 + 40 + 5 = (1 * 10 ^ 4) + (2 * 10 ^ 3) + (3 * 10 ^ 2) + (4 * 10 ^ 1) + (5 * 10 ^ 0) = (1 * 10000) + (2 + 1000) + (3 * 100) + (4 * 10) + (5 * 1) = 10000 + 2000 + 300 + 40 + 5 = 12345 规律: 其它进制转换为十进制的结果 = 系数 * 基数 ^ 索引 之和 系数: 每一位的值就是一个系数 基数: 从x进制转换到十进制, 那么x就是基数 索引: 从最低位以0开始, 递增的数
二进制 --> 十进制 543210 101101 = (1 * 2 ^ 5) + (0 * 2 ^ 4) + (1 * 2 ^ 3) + (1 * 2 ^ 2) + (0 * 2 ^ 1) + (1 * 2 ^ 0) = 32 + 0 + 8 + 4 + 0 + 1 = 45 八进制 --> 十进制 016 = (0 * 8 ^ 2) + (1 * 8 ^ 1) + (6 * 8 ^ 0) = 0 + 8 + 6 = 14 十六进制 --> 十进制 0x11f = (1 * 16 ^ 2) + (1 * 16 ^ 1) + (15 * 16 ^ 0) = 256 + 16 + 15 = 287
十进制除以基数取余, 倒叙读取
十进制 --> 二进制 100 --> 1100100 100 / 2 = 50 0 50 / 2 = 25 0 25 / 2 = 12 1 12 / 2 = 6 0 6 / 2 = 3 0 3 / 2 = 1 1 1 / 2 = 0 1 十进制 --> 八进制 100 --> 144 100 / 8 = 12 4 12 / 8 = 1 4 1 / 8 = 0 1 十进制 --> 十六进制 100 --> 64 100 / 16 = 6 4 6 / 16 = 0 6
// 整数部分(除2取余) 12/ 2------ 6 // 余0/ 2------ 3 // 余0/ 2------ 1 // 余1/ 2------ 0 // 余1//12 --> 1100 // 小数部分(乘2取整数积) 0.125* 2 ------ 0.25 //0 0.25* 2 ------ 0.5 //0 0.5* 2 ------ 1.0 //1 0.0// 0.125 --> 0.001// 12.8125 --> 1100.001
// 整数部分(乘以2的n次方, n从0开始)0 * 2^0 = 00 * 2^1 = 01 * 2^2 = 41 * 2^3 = 8 // 1100 == 8 + 4 + 0 + 0 == 12// 小数部分(乘以2的负n次方, n从0开始)0 * (1/2) = 00 * (1/4) = 01 * (1/8) = 0.125// .100 == 0 + 0 + 0.125 == 0.125// 1100.001 --> 12.125
0.8125* 2-------- 1.625 // 1 0.625* 2-------- 1.25 // 1 0.25* 2-------- 0.5 // 0* 2-------- 1.0 // 1 0.0// 0. 8125 --> 0.1101
1*(1/2) = 0.51*(1/4)=0.250*(1/8)=01*(1/16)=0.0625//0.1101 --> 0.5 + 0.25 + 0 + 0.0625 == 0.8125
计算机只能识别0和1, 所以计算机中存储的数据都是以0和1的形式存储的
数据在计算机内部是以补码的形式储存的, 所有数据的运算都是以补码进行的
正数的原码、反码和补码
0000 0000 0000 0000 0000 0000 0000 11000000 0000 0000 0000 0000 0000 0000 11000000 0000 0000 0000 0000 0000 0000 1100二进制的最高位我们称之为符号位, 最高位是0代表是一个正数, 最高位是1代表是一个负数
一个负数的原码, 是将该负数的二进制最高位变为1
一个负数的反码, 是将该数的原码除了符号位以外的其它位取反
一个负数的补码, 就是它的反码 + 1
例如: -12的原码、反码和补码分别为
0000 0000 0000 0000 0000 0000 0000 1100 // 12二进制 1000 0000 0000 0000 0000 0000 0000 1100 // -12原码 1111 1111 1111 1111 1111 1111 1111 0011 // -12反码 1111 1111 1111 1111 1111 1111 1111 0100 // -12补码
反码 = 补码-1
原码= 反码最高位不变, 其它位取反
1111 1111 1111 1111 1111 1111 1111 0100 // -12补码 1111 1111 1111 1111 1111 1111 1111 0011 // -12反码 1000 0000 0000 0000 0000 0000 0000 1100 // -12原码
在学习本节内容之前,大家必须明白一个东西, 就是计算机只能做加法运算, 不能做减法和乘除法, 所以的减法和乘除法内部都是用加法来实现的
很明显, 通过我们的观察, 如果只有原码, 1-1的结果不对
// 1 + 1 0000 0000 0000 0000 0000 0000 0000 0001 // 1原码 +0000 0000 0000 0000 0000 0000 0000 0001 // 1原码 --------------------------------------- 0000 0000 0000 0000 0000 0000 0000 0010 == 2 // 1 - 1; 1 + (-1); 0000 0000 0000 0000 0000 0000 0000 0001 // 1原码 +1000 0000 0000 0000 0000 0000 0000 0001 // -1原码 --------------------------------------- 1000 0000 0000 0000 0000 0000 0000 0010 == -2
正是因为对于减法来说,如果使用原码结果是不正确的, 所以才引入了反码
// 1 - 1; 1 + (-1); 0000 0000 0000 0000 0000 0000 0000 0001 // 1反码 1111 1111 1111 1111 1111 1111 1111 1110 // -1反码 --------------------------------------- 1111 1111 1111 1111 1111 1111 1111 1111 // 计算结果反码 1000 0000 0000 0000 0000 0000 0000 0000 // 计算结果原码 == -0
虽然反码能够满足我们的需求, 但是对于0来说, 前面的负号没有任何意义, 所以才引入了补码
// 1 - 1; 1 + (-1);
0000 0000 0000 0000 0000 0000 0000 0001 // 1补码
1111 1111 1111 1111 1111 1111 1111 1111 // -1补码
---------------------------------------
10000 0000 0000 0000 0000 0000 0000 0000 // 计算结果补码
0000 0000 0000 0000 0000 0000 0000 0000 // == 0
| 符号 | 名称 | 运算结果 |
|---|---|---|
| & | 按位与 | 同1为1 |
| | | 按位或 | 有1为1 |
| ^ | 按位异或 | 不同为1 |
| ~ | 按位取反 | 0变1,1变0 |
| << | 按位左移 | 乘以2的n次方 |
| >> | 按位右移 | 除以2的n次方 |
9&5 = 1
1001
&0101
------
0001
9|5 = 13
1001
|0101
------
1101
9^5 = 12 1001^0101------ 1100
~9 =-100000 0000 0000 0000 0000 1001 // 取反前1111 1111 1111 1111 1111 0110 // 取反后// 根据负数补码得出结果1111 1111 1111 1111 1111 0110 // 补码1111 1111 1111 1111 1111 0101 // 反码1000 0000 0000 0000 0000 1010 // 源码 == -10
判断奇偶(按位或)
偶数: 的二进制是以0结尾 8 -> 1000 10 -> 1010 奇数: 的二进制是以1结尾 9 -> 1001 11 -> 1011 任何数和1进行&操作,得到这个数的最低位 1000 &0001 ----- 0000 // 结果为0, 代表是偶数 1011 &0001 ----- 0001 // 结果为1, 代表是奇数
权限系统
enum Unix { S_IRUSR = 256,// 100000000 用户可读 S_IWUSR = 128,// 10000000 用户可写 S_IXUSR = 64,// 1000000 用户可执行 S_IRGRP = 32,// 100000 组可读 S_IWGRP = 16,// 10000 组可写 S_IXGRP = 8,// 1000 组可执行 S_IROTH = 4,// 100 其它可读 S_IWOTH = 2,// 10 其它可写 S_IXOTH = 1 // 1 其它可执行 };// 假设设置用户权限为可读可写printf("%d\n", S_IRUSR | S_IWUSR); // 384 // 110000000
交换两个数的值(按位异或)
a = a^b; b = b^a; a = a^b;
2<<1; //相当于 2 *= 2 // 4 0010<<01002<<2; //相当于 2 *= 2^2; // 8 0010<<1000
2>>1; //相当于 2 /= 2 // 1 0010>>00014>>2; //相当于 4 /= 2^2 // 1 0100>>0001
#include <stdio.h>void printBinary(int num);int main(int argc, const char * argv[]) { printBinary(13);}void printBinary(int num){ int len = sizeof(int)*8; int temp; for (int i=0; i<len; i++) { temp = num; //每次都在原数的基础上进行移位运算 temp = temp>>(31-i); //每次移动的位数 int t = temp&1; //取出最后一位 if(i!=0&&i%4==0)printf(" "); printf("%d",t); }}
地址总线: 地址总线宽度决定了CPU可以访问的物理地址空间(寻址能力)
例如: 地址总线的宽度是1位, 那么表示可以访问 0 和 1的内存 例如: 地址总线的位数是2位, 那么表示可以访问 00、01、10、11的内存 数据总线: 数据总线的位数决定CPU单次通信能交换的信息数量
例如: 数据总线:的宽度是1位, 那么一次可以传输1位二进制数据 例如: 地址总线的位数是2位,那么一次可以传输2位二进制数据 控制总线: 用来传送各种控制信号
写入流程
读取流程
先分配字节地址大内存,然后分配字节地址小的内存(内存寻址是由大到小)
变量的首地址,是变量所占存储空间字节地址(最小的那个地址 )
低位保存在低地址字节上,高位保存在高地址字节上
10的二进制: 0b00000000 00000000 00000000 00001010 高字节← →低字节
| 字符 | 意义 |
|---|---|
| \b | 退格(BS)当前位置向后回退一个字符 |
| \r | 回车(CR),将当前位置移至本行开头 |
| \n | 换行(LF),将当前位置移至下一行开头 |
| \t | 水平制表(HT),跳到下一个 TAB 位置 |
| \0 | 用于表示字符串的结束标记 |
\ | 代表一个反斜线字符 \ |
| \" | 代表一个双引号字符" |
| \' | 代表一个单引号字符' |
char ch1 = 'a'; printf("%i\n", ch1); // 97 char ch2 = 97; printf("%c\n", ch2); // a
char类型占一个字节, 一个中文字符占3字节(unicode表),所有char不可以存储中文
char c = '我'; // 错误写法
除转义字符以外, 不支持多个字符
char ch = 'ab'; // 错误写法
char类型存储字符时会先查找对应的ASCII码值, 存储的是ASCII值, 所以字符6和数字6存储的内容不同
char ch1 = '6'; // 存储的是ASCII码 64char ch2 = 6; // 存储的是数字 6
#include <stdio.h>int main(){ // char占1个字节, char的取值范围 -2^7~2^7 char num = 129; printf("size = %i\n", sizeof(num)); // 1 printf("num = %i\n", num); // -127 // short int 占2个字节, short int的取值范围 -2^15~2^15-1 short int num1 = 32769;// -32767 printf("size = %i\n", sizeof(num1)); // 2 printf("num1 = %hi\n", num1); // int占4个字节, int的取值范围 -2^31~2^31-1 int num2 = 12345678901; printf("size = %i\n", sizeof(num2)); // 4 printf("num2 = %i\n", num2); // long在32位占4个字节, 在64位占8个字节 long int num3 = 12345678901; printf("size = %i\n", sizeof(num3)); // 4或8 printf("num3 = %ld\n", num3); // long在32位占8个字节, 在64位占8个字节 -2^63~2^63-1 long long int num4 = 12345678901; printf("size = %i\n", sizeof(num4)); // 8 printf("num4 = %lld\n", num4); // 由于short/long/long long一般都是用于修饰int, 所以int可以省略 short num5 = 123; printf("num5 = %lld\n", num5); long num6 = 123; printf("num6 = %lld\n", num6); long long num7 = 123; printf("num7 = %lld\n", num7); return 0;}
#include <stdio.h>int main(){ // 1.默认情况下所有类型都是由符号的 int num1 = 9; int num2 = -9; int num3 = 0; printf("num1 = %i\n", num1); printf("num2 = %i\n", num2); printf("num3 = %i\n", num3); // 2.signed用于明确说明, 当前保存的数据可以是有符号的, 一般情况下很少使用 signed int num4 = 9; signed int num5 = -9; signed int num6 = 0; printf("num4 = %i\n", num4); printf("num5 = %i\n", num5); printf("num6 = %i\n", num6); // signed也可以省略数据类型, 但是不推荐这样编写 signed num7 = 9; printf("num7 = %i\n", num7); // 3.unsigned用于明确说明, 当前不能保存有符号的值, 只能保存0和正数 // 应用场景: 保存银行存款,学生分数等不能是负数的情况 unsigned int num8 = -9; unsigned int num9 = 0; unsigned int num10 = 9; // 注意: 不看怎么存只看怎么取 printf("num8 = %u\n", num8); printf("num9 = %u\n", num9); printf("num10 = %u\n", num10); return 0;}
signed short int num1 = 666; signed unsigned int num2 = 666; // 报错
相同数据类型数据的有序的集合#include <stdio.h>int main(int argc, const char * argv[]) { /* // 需求: 保存2个人的分数 int score1 = 99; int score2 = 60; // 需求: 保存全班同学的分数(130人) int score3 = 78; int score4 = 68; ... int score130 = 88; */ // 数组: 如果需要保存`一组``相同类型`的数据, 就可以定义一个数组来保存 // 只要定义好一个数组, 数组内部会给每一块小的存储空间一个编号, 这个编号我们称之为 索引, 索引从0开始 // 1.定义一个可以保存3个int类型的数组 int scores[3]; // 2.通过数组的下标往数组中存放数据 scores[0] = 998; scores[1] = 123; scores[2] = 567; // 3.通过数组的下标从数组中取出存放的数据 printf("%i\n", scores[0]); printf("%i\n", scores[1]); printf("%i\n", scores[2]); return 0;}
// int 元素类型// ages 数组名称// [10] 元素个数int ages[10];
int ages[3] = {4, 6, 9};
int nums[] = {1,2,3,5,6};
int nums[10] = {1,2};
int nums[5] = {[4] = 3,[1] = 2};
int nums[] = {[4] = 3};
int nums[3];nums[0] = 1;nums[1] = 2;nums[2] = 3;
int nums[5];printf("%d\n", nums[0]);printf("%d\n", nums[1]);printf("%d\n", nums[2]);printf("%d\n", nums[3]);printf("%d\n", nums[4]);输出结果:00160641631201606416414
int ages[3];ages = {4, 6, 9}; // 报错
// 找到下标为0的元素, 赋值为10ages[0]=10;// 取出下标为2的元素保存的值int a = ages[2];printf("a = %d", a);
int ages[4] = {19, 22, 33, 13}; for (int i = 0; i < 4; i++) { printf("ages[%d] = %d\n", i, ages[i]); }
int ages[4] = {19, 22, 33, 13}; int length = sizeof(ages)/sizeof(int); printf("length = %d", length);输出结果: 4
int ages[4] = {19, 22, 33, 13}; for (int i = 0; i < 4; i++) { printf("ages[%d] = %d\n", i, ages[i]); }
int ages[4] = {19, 22, 33, 13}; for (int i = 3; i >=0; i--) { printf("ages[%d] = %d\n", i, ages[i]); }
#include <stdio.h>int main(){ int num = 9; char cs[] = {'l','n','j'}; printf("cs = %p\n", &cs); // cs = 0060FEA9 printf("cs[0] = %p\n", &cs[0]); // cs[0] = 0060FEA9 printf("cs[1] = %p\n", &cs[1]); // cs[1] = 0060FEAA printf("cs[2] = %p\n", &cs[2]); // cs[2] = 0060FEAB int nums[] = {2, 6}; printf("nums = %p\n", &nums); // nums = 0060FEA0 printf("nums[0] = %p\n", &nums[0]);// nums[0] = 0060FEA0 printf("nums[1] = %p\n", &nums[1]);// nums[1] = 0060FEA4 return 0;}
注意:字符在内存中是以对应ASCII码值的二进制形式存储的,而非上述的形式。
char cs1[2] = {1, 2};
char cs2[3] = {3, 4, 5};
cs2[3] = 88; // 注意:这句访问到了不属于cs1的内存
printf("cs1[0] = %d\n", cs1[0] );
输出结果: 88
为什么上述会输出88, 自己按照"数组内部存储细节"画图脑补
int ages4['A'] = {19, 22, 33};
printf("ages4[0] = %d\n", ages4[0]);
int ages5[5 + 5] = {19, 22, 33};
printf("ages5[0] = %d\n", ages5[0]);
int ages5['A' + 5] = {19, 22, 33};
printf("ages5[0] = %d\n", ages5[0]);
// 没有指定元素个数，错误
int a[];
// []中不能放变量
int number = 10;
int ages[number]; // 老版本的C语言规范不支持
printf("%d\n", ages[4]);
int number = 10;
int ages2[number] = {19, 22, 33} // 直接报错
// 只能在定义数组的时候进行一次性（全部赋值）的初始化
int ages3[5];
ages10 = {19, 22, 33};
// 一个长度为n的数组,最大下标为n-1, 下标范围:0~n-1
int ages4[4] = {19, 22, 33}
ages4[8]; // 数组角标越界
void change(int val)// int val = number{ val = 55;}int main(int argc, const char * argv[]){ int ages[3] = {1, 5, 8}; printf("ages[0] = %d", ages[0]);// 1 change(ages[0]); printf("ages[0] = %d", ages[0]);// 1}
用数组元素作函数参数不要求形参也必须是数组元素
void change2(int array[3])// int array = 0ffd1{ array[0] = 88;}int main(int argc, const char * argv[]){ int ages[3] = {1, 5, 8}; printf("ages[0] = %d", ages[0]);// 1 change(ages); printf("ages[0] = %d", ages[0]);// 88}
void change(int array[]){ array[0] = 88;}
void prtArray(double array[3]) // 错误写法{ for (int i = 0; i < 3; i++) { printf("array[%d], %f", i, array[i]); }}int main(int argc, const char * argv[]){ int ages[3] = {1, 5, 8}; prtArray(ages[0]);}
void printArray(int array[]){ printf("printArray size = %lu\n", sizeof(array)); // 8 int length = sizeof(array)/ sizeof(int); // 2 printf("length = %d", length);}
