Hello World
#include<stdio.h>
int main(int argc,const char * argv[])
{
printf("hello world\n");
return 0;
}注意：给新手小白说一下
- 所有的标点符号必须在英文状态下输入
- 所有的单词不要写错
- 注意空格的使用
注释
作用：对代码的解释说明
语法：
单行注释
// 注释的内容
块注释
/*
注释的内容
可多行注释
*/
注意：注释的时候不能嵌套
输出
作用：给控制台输出内容
语法：
printf("输出的内容"，位置1，位置2，...);
注意：后面值的数量取决于字符串中有多少个占位符
占位符
%d 十进制有符号整数
%u 十进制无符号整数
%x 以十六进制表示的整数 %o 以八进制表示的整数
%f float 型浮点数
%lf double 型浮点数
%e 指数形式的浮点数
%s 字符串
%c 单个字符
%p 指针的值
注意：%.2f 小数点后保留两位
标识符
概念：标记的符号，名称
如： 变量名，函数名，数组名，枚举符，结构题名..... 命名规则： 不能使用数字开头 不能使用特殊符号，_与$除外 不能使用关键字 不能使用中文 命名风格： 驼峰命名法： 大驼峰 写法：每个单词首字母大写 一般用于：枚举名，结构体名 小驼峰 写法：第一个单词首字母小写，其他单词首字母大写 一般用于：变量名，数字名，函数名等 全大写 写法：全大写 一般用于：常量名 全小写 写法：全小写 一般用于：文件夹名 linux风格命名法 多个单词之间使用下划线连接 如：hello_world 注意：取名的时候尽量做到见名知意
关键字
数据类型相关
short：短整型
int ：整形
long：长整型
float：单精度浮点数
double：双精度浮点数
char：字符struct：结构体
unionL：共用体
enum：枚举
signed：有符号
unsigned：无符号
void：空的返回值类型
存储相关
register：寄存器存储
static：静态的
const：不可修改的
auto：自动
extern：声明
控制语句相关
if
else
break
continue
for
while
do
switch
case
goto
default
register
一般情况下不要使用
register关键字是用来提示编译器将变量存储在寄存器中，以提高访问速度。然而，现代编译器通常会自动进行寄存器分配，因此使用register关键字并不能保证变量一定会存储在寄存器中。
volatile
格式：volatile 数据类型 变量名 = 值; volatile关键字用于确保对变量的读写操作是可见的，防止编译器对其进行优化（就是防止编译器将变量存储到寄存器中），当一个变量被声明为volatile时，编译器会保证每次访问该变量时都会从内存中读取最新的值，而不是使用缓存的值。这对于多线程或并发编程中的共享变量是非常重要的。
const
格式：const int a=10;
作用是将变量修改为常量。
变量前面加上const后，a值不可修改，变成常量
typedef
格式：typedef 已有的数据类型 新名称；
例：typedef int Integer；
int num=10; 等价于 Integer n=10;
作用：给已有的数据类型重新创建一个新的名称。
使用typedef可以方便地定义复杂的类型，例如结构体、指针等。它可以提高代码的可读性，并使类型声明更加清晰和简洁。
signed
有符号的关键字，推荐第二种写法 格式： 第一种写法：signed int a=0; 第二种写法：int a=0; (推荐第二种写法)
unsigned
无符号数关键字，必须加unsigned。
格式：unsigned int a=0;
注意：
C语言中8进制数与16进制数都是无符号数 8进制数以0开头 16进制数以0x开头 2进制数以0b开头
数据类型
char 字符型 1字节 8位
short 短整型 2字节 16位
int 整型 4字节 32位
long 长整型 4字节（32位）8字节（64位）
float 单精度浮点型 4字节 32位
double 双精度浮点型 8字节 64位
变量
1.声明（在某些特殊情况下才需进行）
2.定义：
语法：
数据类型 变量名；
数据类型 变量名 = 值；
注意：变量的第一次赋值称为变量的初始化
在函数中定义的变量为局部变量，局部变量默认使用auto修改此时默认值为一个随机数
在函数外定义的变量为成员变量
#include<stdio.h>
//函数外
int main()
{
//函数中
}
//函数外类型的转换
自动转换
小类型转换为大类型，无需特殊处理
//'a' 的数据类型为 char 占1字节
//int 占4字节
int num = 'a';
printf("num=%d\n",num);注意：
每一个字符都有对应的数字
其中 a~z 97~122
A~Z 65~90
强制转换
大类型转换为小类型，需强转，有风险
小类型变量名 = （小类型）大类型数值或变量
int num = 'a';
char c = (char)num;
printf("c=%c\n",c);
源码 反码 补码
注意：计算机底层以补码形式存储数据
1.数值对应的二进制数，最高位为符号位，正数为0，负数为1
正数三码合一，与源码相同
负数的反码等于符号位不动，其他位取反；负数的补码等于反码+1
如：
int num = 1;
源码: 0000 0000 0000 0000 0000 0000 0000 0001
反码: 0000 0000 0000 0000 0000 0000 0000 0001
补码: 0000 0000 0000 0000 0000 0000 0000 0001
int n01 = -1;
源码: 1000 0000 0000 0000 0000 0000 0000 0001
反码: 1111 1111 1111 1111 1111 1111 1111 1110
补码: 1111 1111 1111 1111 1111 1111 1111 1111
数据的存和取
注意：计算机存储的是补码，计算机取值是先将补码转换为源码，再将源码转换为10进制数
int num = 0xf1 11 11 11;
计算机存储的num是:
1111 0001 0001 0001 0001 0001 0001 0001
计算机取出的num是:
补码:
1111 0001 0001 0001 0001 0001 0001 0001
反码:
1111 0001 0001 0001 0001 0001 0001 0000
源码:
1000 1110 1110 1110 1110 1110 1110 1111
如：
如：
char c = 0xf0;
1111 0000
1110 1111
1001 0000
- 1 * 2^4 = -16
如：
char c = 0x80;
1111 1111 1000 0000
1111 1111 0111 1111
1111 1111 1000 0000
-1 *128=-128注意：前八位是符号位，因为char是一个字节占8位，所以它的补码是负数，然后通过补码算出反码，需要对补码进行-1操作，但是补码只有符号位，所以给补码前面补1，补的1都是符号位，不参与运算，原来的符号位1，用来进行-1操作
案例：
#include<iostream>
#include<bitset>
using namespace std;
int main()
{
char c=0x80;
cout<<bitset<16>(c)<<endl;
return 0;
}
//注意：bitset<16>(c)表示打印出c的16进制数运算符
1.赋值运算符
= 将等号右边的值赋值给左边
例：int x = 10;
//将10赋值给变量x。
2.算术运算符
int a=4;
int b=2;
+ :加法 int num=a+b;
- :减法 int num=a-b;
* :乘法 int num=a*b;
/ :除法 int num=a/b;
% :取余 int num=a%b;
++ :自增（递增）/ -- :自减（递减）
++ 在前：先自增，再参与运算
++ 在后：先参与运算，在自增
3.复合运算符
1. 加法赋值运算符（+=）：该运算符将变量的当前值与右侧操作数相加，并将结果赋值给左侧操作数。例如，total += 100将total的当前值与100相加，并将结果存储回total中。
2. 减法赋值运算符（-=）：该运算符将变量的当前值与右侧操作数相减，并将结果赋值给左侧操作数。例如，total -= 50将total的当前值减去50，并将结果存储回total中。
3. 乘法赋值运算符（*=）：该运算符将变量的当前值与右侧操作数相乘，并将结果赋值给左侧操作数。例如，total *= 3将total的当前值乘以3，并将结果存储回total中。
4. 除法赋值运算符（/=）：该运算符将变量的当前值与右侧操作数相除，并将结果赋值给左侧操作数。例如，total /= 2将total的当前值除以2，并将结果存储回total中。
5. 取模赋值运算符（%=）：该运算符将变量的当前值与右侧操作数取模，并将结果赋值给左侧操作数。例如，total %= 7将total的当前值对7取模，并将结果存储回total中。
需要注意的是，复合运算符的两边应该是相同的类型，或者是可以隐式转换的类型。在上面的例子中，运算符两边的操作数可以是整数或浮点数，但是类型必须一致。
4.关系运算符
关系运算符用于比较两个值之间的关系，有以下六种关系：
1.小于（<）: 当左侧的值小于右侧的值时，结果为真。
2.大于（>）: 当左侧的值大于右侧的值时，结果为真。
3.小于等于（<=）: 当左侧的值小于或等于右侧的值时，结果为真。
4.大于等于（>=）: 当左侧的值大于或等于右侧的值时，结果为真。
5.等于（==）: 当左侧的值与右侧的值相等时，结果为真。
6.不等于（!=）: 当左侧的值与右侧的值不相等时，结果为真。
注意：这些运算符的结果为布尔值（True 或 False）。
bool类型
bool类型只有两个值
true 真
false 假
5.逻辑运算符
1、逻辑或（OR）运算符：||
当两个条件中有一个或全部满足某个要求时，则表达式的值为真。（条件：一个真或全为真 结果：则为真）。
备注：如果最左侧的表达式为真时，将不会判断下一个表达式，提高电脑运行效率。2、逻辑与（AND）运算符：&&
当两个条件为真时，则表达式的值为真。（条件：两个都要为真 结果：则为真）。
备注：&&运算符允许建立一系列的if else if else 语句,进行设置取值范围。3、逻辑非（NOT）运算符： ！
将!后面的表达式的真值取反。（条件：真/假 结果：假/真）。
即：你是真，我变成假；你是假，我变成真。
备注：非运算符对于返回值ture-flase值或可以被解释为ture-flase值的函数非常有用。4、逻辑运算符的细节
（1）逻辑OR（或）和逻辑AND（与）的运算符的优先级低于关系运算符。
（2）逻辑！（非）的优先级高于所有的关系运算符和算术运算符。
（3）逻辑OR（或）运算符的优先级低于逻辑AND（与）的运算符的优先级。
6.位运算符
位运算符是对二进制位进行操作的运算符。在C++、Java、JavaScript等编程语言中，有如下位运算符：
按位与（&）：全1为1，有0为0。即用于判断最后一位二进制是否为1，来辨别奇偶。
按位或（|）：有1为1，全0为0。
按位异或（^）：相同为0，不同为1。任何两个相同的数字进行异或操作，所得到的结果都必然为0。
取反(~)：只有在C++中是单目运算符，其他都是双目运算符。
左移(<<)：左移运算有乘以2的N次方的效果。一个数向左移动1位，就相当于乘以2的1次方。位移操作在实际运算时远远快于乘法操作。注意：当位移的位数很多时，导致最左边的符号位发生变化，就不再具有乘以2的N次方的效果了。
右移(>>)：右移运算符“>>”是双目运算符，其功能是把“>>”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。
注意：对于有符号数，在右移时，符号位将随同移动。当为正数时，最高位补0;而为负数时，符号位为1，最高位是补0或1取决于编译系统的规定。另外，右移相当于将运算对象除2。总的来说，位运算符在处理二进制数据、对硬件操作等问题时非常有用。
7.三目运算符
语法：条件表达式？值1：值2；
如：a > b ? a : b
条件表达式：返回值为bool型都是条件表达式
值：变量或者常量
逻辑：如果条件表达式的值为真，取值1，否则，取值2；
8.逗号运算符
，：顺序取值运算
注意：该运算符的优先级最低
9.运算优先级
以下是常见的一些运算符和它们的优先级，从高到低：
1. 括号（圆括号、方括号、花括号）
2. 成员访问（例如，a.b 或 a->b）
3. 自增、自减（例如，++a 或 a--）
4. 求反、取地址、取类型（例如，!a、&a、*a）
5. 乘法、除法、取余（例如，a*b、a/b、a%b）
6. 加法、减法（例如，a+b、a-b）
7. 移位（例如，a<<b、a>>b）
8. 位与（例如，a&b）
9. 位异或（例如，a^b）
10. 位或（例如，a|b）
11. 逻辑与（例如，a&&b）
12. 逻辑或（例如，a||b）
13. 三元条件运算符（例如，a?b:c）
14. 赋值运算符（例如，a=b、a+=b）
15. 逗号运算符（例如，a,b)自左向右
随机数
作用：随机获取一个数字
对应的头文件
stdlib.h
time.h
相关函数
srand()
rand()
使用
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main()
{
srand(time(NULL));
int num=rand()%11;
//获取0~10的随机数
printf("%d",num);
return 0;
}
输入
作用：通过键盘等其他可输入设备给程序中输入数据
使用：
定义接收输入的数据的变量
int a = 0;
输入
scanf("%d",&a);
案例
要求：键盘输入两个数，计算两数之和
#include<stdio.h>
int main()
{
int a,b;
printf("请输入第一个数：\n");
scanf("%d",&a);
printf("请输入第二个数：\n");
scanf("%d",&b);
int num=a+b;
printf("两数之和为：%d\n",num);
return 0;
}分支语句
作用：判断
if语句
if(条件表达式1)
{
当条件表达式1为真,执行此处代码
}
else if(条件表达式2)
{
当条件表达式2为真,执行此处代码
}
else if(条件表达式3)
{
当条件表达式3为真,执行此处代码
}
...
else if(条件表达式n)
{
当条件表达式n为真,执行此处代码
}
else
{
当以上条件都不为真,执行此处代码
}
注意：
- else if可以有多个，也可以一个没有
- 当多个条件同时满足，只执行最上面的一个
- 0，NULL，false都是false，其他都为true
switch语句
语法:
switch(变量名)
{
case 常量1:
当变量值等于把常量1时执行此处代码
break;
case 常量2:
当变量值等于把常量2时执行此处代码
break;
...
case 常量n:
当变量值等于把常量n时执行此处代码
break;
default:
当变量不等于以上所有常量时,执行此处代码
break;
}
注意：
- case可以有多个，也可以一个没有
- default可有可无，最多只能有一个
- break跳出当前代码块，break可以不写，不会写会导致贯穿
- 不支持判断字符串内容是否相同
循环语句
作用：重复执行一段代码
while
语法：
while(条件表达式)
{
循环体：重复执行的代码
}执行流程：
先判断条件表达式是否为真，如果为真，执行循环体中的代码，执行完毕后再次判断表达式是否为真，如果为真。执行循环体中的代码，如果为假，结束循环体
注意：
死循环：无法停止的循环
案例
int i = 0;
while(i <= 100){
if(i % 2 == 0){
printf("%d\n",i);
}
i++;
}do while
语法：
do
{
循环体
}
while(条件表达式);
执行流程：
先执行一次循环体,在判断条件表达式是否为真,如果为真,再次执行循环体,如果为假结束循环
注意：
请问那个循环的循环体至少执行一次(面试题)
do while
for
语法：
for(表达式1;条件表达式2;表达式3)
{
循环体4
}
表达式1:初始化变量
条件表达式2:循环条件
表达式3:改变变量执行流程：
1,2,4,3,2,4,3...2
注意:表达式1只执行一次
案例
for(int i = 0; i < 10; i++)
{
printf("%d\n",i);
}流程控制语句
- break 跳出当前循环
- continue 跳过本次循环
- goto 跳转到指定位置(禁用)
综合案例(水仙花数)
键盘录入一个三位数，判断该数是否为水仙花数
水仙花数为
个位的立方+十位的立方+百位的立方 = 该数本身#include<stdio.h> int main() { int num; scanf("%d",num); if(num >= 100 && num <= 999) { int g = num % 10; int s = num / 10 % 10; int b = num / 100; if(g * g * g + s * s * s + b * b * b == num) { printf("%d是水仙花数\n",num); } else { printf("%d不是水仙花数\n",num); } } else { printf("输入的数不是三位数\n"); } return 0; }
综合案例(鸡兔同笼)
养殖户将鸡与兔子放在同一个笼中
该养殖户无法数清鸡的数量与兔的数量
但是该养殖户数出了腿的数量与头的数量
腿60
头20
请您帮助养殖户计算鸡兔个几何
数学思想:
设:兔子有t只,鸡有j只
4 * t + 2 * j = 60;
t + j = 20;
t = 20 - j;
4 * (20 -j ) + 2j = 60;
80 -4j + 2j = 60;
80 - 2j = 60;
80 - 60 = 2j;
20 = 2j;
j = 10;
t = 10;
代码思想:
鸡的取值范围:0~20
兔的取值范围:0~15#include<stdio.h> int main() { int tag = 0; for(int j = 0; j <= 20; j++) { for(int t = 0; t <= 15; t++) { if(j + t == 20 && 4 * t + 2 * j == 60) { tag = 1; printf("鸡有:%d只,兔有:%d只\n",j,t); } } } if(tag) { printf("输入的头与腿数量正确\n"); } else { printf("此题无解,头腿数量有误\n"); } return 0; }
综合案例(百文百鸡)
中国古代,有一个人去市场买鸡
公鸡3文钱一只
母鸡2文钱一只
小鸡1文钱三只
这个人有100文钱,要求买100只鸡
请问他可以有多少中买法,每种每种买法可以可以公鸡多少只,母鸡多少只,小鸡多少只
数学思路
假设:
公鸡x只
母鸡y只
小鸡100-x-y只
3 * x + 2 * y + (100 -x -y) / 3 = 100;
x + y + (100 - x - y) = 100;
代码思路:
公鸡取值范围:0~33
母鸡取值范围:0~50
小鸡取值范围:0~100#include<stdio.h> int main() { int num = 0; for(int g = 0; g < 34; g++) { for(int m = 0; m < 51; m++) { int x = 100 - g - m; if( 3 * g + 2 * m + x / 3 == 100 && x % 3 == 0) { printf("公鸡:%d只,母鸡:%d只,小鸡:%d只\n",g,m,x); num++; } } } printf("共有%d种买法\n",num); return 0; }
函数
作用
封装一段代码,使其便于使用
注意:
一个功能可以封装一个函数
定义函数的时候一切以功能为目的，根据功能去定函数的参数和返回值
分类
1.库函数 (c 库实现的)
不能直接操作内核
2.系统调用 (操作系统实现的函数)
可以直接操作内核
3.自定义函数 （程序员自己实现的函数）
1,定义
2,调用
使用步骤
1.声明（可有可无）
语法:
extern 返回值类型 函数名(形参列表);
注意:
在函数外声明
声明函数时可以忽略形参的变量名不写
2.定义
语法:
返回值类型 函数名(形参列表)
{
函数体
}
- 返回值类型:返回值的数据类型,当函数没有返回值,返回值类型为void(空类型)
- 函数名:标识符,自定义的
- 形参列表:根据实际情况,可有可无,多个参数之间使用逗号隔开,每个参数有数据类型变量名编写
- 函数体:封装的代码
return:结束当前函数
return xxx:结束当前函数并返回xxx,xxx就是返回值
注意:
- 一个函数最多只能有一个返回值
- 同一个源文件中函数名不能重复(C语言不支持重载)
- 函数不能定义在函数中
定义函数计算10+1的结果 void add01() { int x = 10 + 1; printf("x=%d\n",x); } 定义一个函数计算两数之和 void add02(int x,int y) { int sum = x + y; printf("sum=%d\n",sum); } 定义一个函数计算 1 + 2的结果,并将结果返回给调用处 int add03() { int x = 1 + 2; return x; } 定义一个函数判断是否成年,成年返回1,未成年返回0 int isCN(int age) { if(age >= 18) { return 1; } else { return 0; } }
3.调用
语法:
调用无返回值的函数
函数名(实参列表);
调用有返回值的函数
函数名(实参列表);
变量名 = 函数名(实参列表);
注意:
- 实参列表要与形参列表一致(长度一致,顺序一致,数据类型一致)
- 一个函数可以被调用无数次
- 只能在函数中调用
add01(); add02(1,2); add02(5,10); int a = 1; int b = 9; add02(a,b); add03(); int x = add03(); isCN(19); int y = isCN(20); int age = 17; int z = isCN(age);
数组
概念：容纳数据类型相同的多个数据的容器
特点：
- 长度不变
- 容纳数据类型相同
名词：
- 元素：数据中存储的数据
- 下标：元素在数组中的位置，下标从0开始，长度-1结束
- 长度：数组中可存储元素个数
注意：数组中的数据在内存中有序存储的，是连续的
分类
按存储的数据类型分类
字符数组
整型数组
浮点型数组
...
按照维度分类
一维数组
二维数组
...
一维数组
1.定义与初始化
语法
数据类型 数组名[长度] = {值1，值2，值3，值4，...};
初始化
全部初始化：
如：
int nums01[5]={1,3,5,7,9};
此时长度可以省略
int nums01[]={1,3,5,7,9};
部分初始化：
注意：没有初始化部分值，默认为0
如：
int nums02[5]={1,3,5};
字符数组与字符串
char str01[5]={'h','e','l','l','o'};
char str02[]="hello";
/*注意：
将字符串赋值给字符数组，系统将默认为其在尾部加\0
\0字符串结束符
*/2.使用
1.修改指定位置的元素
int nums[5]={1,3,5,7,9};
//将数组中下标为1的元素修改为33
num[1]=33;2.计算数组长度
数组所占字节数大小/单个元素所占大小 = 长度
int nums[] = {1,2,3,4,5,6,7,8,89,9,10,1,21,121,121,21,3,32};
//方法1
int len = sizeof(nums) / sizeof(nums[0]);
//方法2
int len = sizeof(nums) / sizeof(int);
3.遍历
将数组中的数据逐个取出
void fun05()
{
int nums[] = {1,2,3,4,5,6,7,8,89,9,10,1,21,121,121,21,3,32};
//计算数组长度
int len = sizeof(nums) / sizeof(nums[0]);
//开启循环
for(int i = 0; i < len; i++)
{
//取值
int x = nums[i];
//打印
printf("%d,",x);
}
printf("\n");
}
4.字符串录入
scanf 不能录入空格
gets 会出现bug
fgets 最优选择
语法: fgets(数组名,sizeof(数组名),stdin);
5.数组与函数
注意:
数组的本质是一个地址,所以调用函数时传入数组,其实传递的是数组名对应的地址
此时当函数中将该数组中的内容修改,那么调用该函数所传递的数组的值也将被修改
#include <stdio.h>
void funA(int a)
{
a = 10;
}
void funB(int nums[5])
{
nums[0] = 10;
}
/*
要求定义一个函数,计算两数之和,要求返回和,加数,被加数
*/
void add(int a,int b,int nums[3])
{
int x = a + b;
nums[0] = x;
nums[1] = a;
nums[2] = b;
}
int main(int argc, char const *argv[])
{
int x = 1;
funA(x);
printf("x= %d\n",x);
int xs[5] = {1};
funB(xs);
printf("xs[0] = %d\n",xs[0]);
int adds[3] = {0};
add(10,2,adds);
for(int i = 0; i < 3; i++)
{
printf("%d\n",adds[i]);
}
return 0;
}
二维数组
概念
将一维数组作为元素存储的数组
使用
1.定义与初始化
数据类型 数组名[x][y] = {
{值1,值2,值3,...},
{值11,值22,值33,...},
{值111,值222,值333,...},
... };
x:二维数组中存储的一维数组的个数
y:一维数组中可存储的元素的个数
几种书写方法：
#include <stdio.h>
int main(int argc, char const *argv[])
{
//数组初始化的三种书写方法
int nums01[3][3] = {
{1,2,3},
{4,5,6},
{7,8,9}
};
//当数组全部初始化时可以省略长度不写
//二维数组的长度是一维数组的个数
int nums02[][3] = {
{1,2,3},
{4,5,6},
{7,8,9}
};
int nums03[3][3] = {1,2,3,4,5,6,7,8,9};
//将数组初始化为0的书写方法
int nums04[3][3] = {
{0},
{0},
{0}
};
int nums05[3][3] = {0};
return 0;
2.长度
sizeof(数组名) / sizeof(数组中第一个元素) = 长度
3.遍历
遍历普通类型
1,获取二维数组中一维数组的个数,即二维数组的长度,为x
2,获取一维数组中元素的个数,即一维数组的长度为y
3,开启循环,逐个获取二维数组中的一维数组
4,在循环内遍历获取到的一维数组
void fun01()
{
int nums[5][3] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
int xlen = sizeof(nums) / sizeof(nums[0]);
int ylen = sizeof(nums[0]) / sizeof(nums[0][0]);
for(int i = 0; i < xlen; i++)
{
//nums[i]
for(int j = 0; j < ylen; j++)
{
int x = nums[i][j];
printf("%d,",x);
}
printf("\n");
}
}void fun02()
{
char strs[3][128] = {0};
for(int i = 0; i < 3; i++)
{
fgets(strs[i],sizeof(strs[i]),stdin);
}
for(int i = 0; i < 3; i++)
{
printf("%s",strs[i]);
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
