常量 不能被改变的量
整型常量
1 2 3 0 -1 -2 ……
实型常量
1.11 10.0 …… 由数字和小数点组成 1.23e6 = 1.23*10^6 e/E 之前必须有数字 之后必须为整数
字符常量
'a' 'b' 一对 单引号 括起来的 一个字符
字符串常量
''abcd" 一对 双引号 括起来 多个字符
地址常量
常量 变量 数组的地址 在运行时 不会改办 这些 地址为 地址常量
变量 可改变值的量
#include <stdio.h>
int main(){
int age = 18;
age = 19;
}
初始化: 数据类型 变量名 = 数值
int — 数据类型 age — 变量名 = — 赋值 == — 等于
int age = 18; — 定义初始化
int age — 定义 （数据类型+变量名）
标识符命名规则
数字 字母 下划线_ 字母和下划线开头 区分大小写 ｜ 不可数字开头 不能是关键字 不能在 一个范围 重名
数据类型 — 存储形式(二进制) 单元长度
0 / 1 1字节 8 位 ASCLL码表
| 0 | 1 | … .. |
- int 整型 整数形式的数据 0 +-1 +- 2… 4 字节 32位 取值范围: 2^32
unsigned 无符号 ( 范围 0——2^32-1 ) signed 有符号 ( 范围 -2^31——2^31-1 ) —- 有无正负
- char 字符型 1字节 8 位 取值范围: 2^8 256 0——2^8-1 -2^7——2^7-1
- float 单精度浮点型 4字节 精确度: 小数点后 5-6位 0.314159e1 = 3.14159
- double 双精度浮点型 8字节 精确度: 小数点后 15-16位
- long 长整型 和整形一样 取值范围不一样 比整形 长
- short 短整形 和整形一样 取值范围不一样 比整形 短
格式化输入和输出
格式化输入
scanf 格式化输入函数
使用格式: scanf (格式控制,地址列表)；
#include <stdio.h>
int main(){
int w;
scanf("%d",&w);
}
格式控制 — 是一个字符串 " 占位符 " 简称 格式字符串
占位符分类
%d 整型 %c 字符型 %f float %lf double
输入列表 — &w;
格式化输出
printf 格式化输出函数
使用格式: printf (格式控制,输出列表)；
#include <stdio.h>
int main(){
int w;
scanf("%d",&w);
printf("%d",w);
getchar();
return 0;
}
输出列表 — 程序需要输出 数据 可以 变量 常量 表达式
getchar();
功能: 等待 从键盘上输入数据 读取一个字符 以回撤结束
putchar();
功能: 可以是 字符变量 和 常量
#include <stdio.h>
int main(){
char w;
w=getchar();
putchar(w);
return 0;
}
————————-
输入 qwe
输出 q
运算符
算术运算符 + – * /
a*b a/b %取余 17%3=2
a++ = a+1 先使 a值 作为 这个式子 a++值 执行完后 再加一
a– = a-1 先使 a值 作为 这个式子 a–值 执行完后 再减一
++a = a+1 先执行 a+1 的结果 使这个结果作为式子的值
–a = a-1 先执行 a-1 的结果 使这个结果作为式子的值
关系运算符
> 大于 < 小于 >= 大于等于 <= 小于等于 == 等于 ( = 赋值作用) != 不等于
逻辑运算符
&& 逻辑与 全真为真 有假为假
#include<stdio.h>
int main(){
int x;
x = 1 == 0 && 2 < 3;
printf("%d", x);
}
—————————–
0 假
|| 逻辑或 有真为真 全假为假
#include<stdio.h>
int main(){
int x;
x = 1 == 0 || 2 < 3;
printf("%d", x);
}
—————————–
1 真
! 逻辑非 ！表否
#include<stdio.h>
int main(){
int x;
x =!( 1 == 0 || 2 < 3);
printf("%d", x);
}
—————————–
0 假
赋值运算符
= 左边 必须一个 变量 右边 一个 值 int x= 10；
+= a+=10 先进行 a+10 a=a+10
-= a-=10 先进行 a-10 a=a-10
*= a*=10 先进行 a*10 a=a*10
/= a/=10 先进行 a/10 a=a+/10
%= a%=10 先进行 a%10 a=a%10
三目运算符
格式: 表达式1?表达式2:表达式3
表达式1 为真 使用 表达式2 作为式子结果 为假 使用 表达式3 作为式子结果
//比较俩数大小
int a = 56, b = 34;
int c = a>b?a:b;
———————–
(1 > 2) ? 1 : 2 // 返回 2
(3 > 2) ? 1 : 2 // 返回 1
位运算符 (二进制)
数值 变为 二进制 再去运算
<< 左移 二进制中 数值 整体 向左移动 3<<2 0011 1100=12 a<<n a✖️2^n
>> 右移 二进制中 数值 整体 向右移动 3>>2 0011 0000=0. a>>n a/2^n
~ 按位非 二进制 取反 ~3 0011 1100 1 变 0 0 变 1
| 按位或 3|12 0011 1100 1111=16 对应位 有 1 为 1 全 0 为 0
& 按位与 3&12 0011 1100 0000=0 对应位 有 0 为 0 全 1 为 1
^ 按位异或 3^12 0011 1100 1111=16 对应位 相同 为 0 不同 为 0
c语言 基本结构
顺序结构
执行代码 从 主函数 int mian() 开始 从上至下
选择分支结构
两条分支可选 达成条件就执行 反之 换另一条
if 结构
if(表达式) 语句 —– 判断表达式 真假 真 执行语句 假 不执行
//比较 三数中 第一个数 是不是 最大值
int num1, num2, num3;
scanf ("%d %d %d",&num1,&num2,&num3);
if (num1>num2&&num1>num3)
printf("第一个为最大值");
—————————————–
num1>num2>num3 数学中 可以 c语言 不可
if else 选择结构
if (表达式/判断条件) {
语句1} else {
语句2} //else 不可单独使用 搭配 if
if 判断条件 真 执行语句1 假 执行else中 语句2
//判断 是否成年 >=18
#include<stdio.h>
int main(){
int age;
scanf("%d",&age);
if(age>=18){
printf("已成年");
} if(age<22){
printf("大学生");
}else {
printf("未成年");
}
}
if else 嵌套
if (表达式) {
if(条件2){
语句1
} else {
语句2}
} else {
if (条件3) {
语句3
} else {
语句4}
}
#include<stdio.h>
int main(){
int iday=0;
int mon=1, tue=2, wed=3, thur=4, fri=5, sat=6, sun=7;
printf("enter a day of week to get course:\\n");
scanf("%d",&iday);
if(iday>fri)
{
if(iday==sat)
{
printf("go shopping with friends\\n");
} else {printf("at home with families\\n");}
} else
{
if(iday==mon)
{
printf("have a metting in company\\n");
} else {printf("working with partner\\n");}
}
return 0;
}
switch 选择分支 / 开关语句
switch(条件){
case 0:语句1;break; //跳出判断
case 1:语句2;break;
case 2:语句3;break;
case 3:语句4;break;
default:语句5;break;
} //拿判断结果 与 case 后面进行比较
//若等于就执行后面语句 然后跳出
//若不等于则往下执行 直到不符合
//选择我默认的(default)为结果
//通过分数分等级
int grade;
scanf("%d",&grade);
switch(grade/10){
case 10:printf("优秀");break;
case 9:printf("优秀");break;
case 8:printf("良好");break;
case 7:printf("良好");break;
case 6:printf("合格");break;
default:printf("不合格");break;
}
循环结构 :重复去做
for循环 c语言最常见循环
for(表达式1,表达式2,表达式3){
循环体(循环的事情)
}
表达式1 第1步 初始化语句 只有在 循环开始时 才执行一次
表达式2 第2步 条件判断 真 执行循环体 假 退出循环体
第3步 执行循环体
表达式3 第4步 变量变化
循环执行2-4步
//跑步10圈计数
int count=0;
for(int i=1;i<=10;i++){
count=i;
printf("%d",count);
} //侧重循环次数
while循环
while(判断条件){
循环体
} //侧重判断条件 而不是 循环次数
执行过程 判断条件 真 去执行循环体 执行完后 去判断条件是否为真 知道 判断条件为假 结束
//跑步10圈计数
int j=1;
while(j<=10){
printf("%d",j); //j本身 不会进行 改变
j++;
}
do while 循环
do{
循环体
} while (判断条件);
执行过程 第1步 执行 循环体
第2步 执行 条件判断 真 回到 第1步 假 结束 while循环
int j=0;
do{
printf("%d",j);
j++;
} while (j<=10);
do while 不管条件 都会 先执行 1次 循环体
双层for循环
#include<stdio.h>
int main(){
int i=0, j=0;
for(i=1;i<=9;i++){
for(j=1;j<=9;j++){
printf("%d*%d=%d\\t",i,j,i*j);
}
printf("\\n");
}
}
#include<stdio.h>
int main(){
int i=0, j=0;
for(i=1;i<=9;i++){
for(j=1;j<=9;j++){
if(i<=j){
printf("%d*%d=%d\\t",i,j,i*j);
}
}
printf("\\n");
}
}
——————————————
#include<stdio.h>
int main(){
int i=0, j=0;
for(i=1;i<=9;i++){
for(j=1;j<=i;j++){
printf("%d*%d=%d\\t",i,j,i*j);
}
printf("\\n");
}
}
数组
一维数组
变量：只保存一个 数组：多个 数据类型 相同
定义格式 数据类型 数组名字 [数组长度]; —– 表示数组大小 有多少数组元素
int day[30]; //只能保存一种数据类型 长度定义后 不可更改
一维数组初始化
在 数组定义 时 给 数组 赋值
定义格式 数据类型 数组名字 [数组长度]={初值1,初值2,初值3,……}
int a[5]={1,2,3,4,5}; //数据个数 等于 数组长度
int b[10]={1,2,3}; //剩下 7个 默认 为 0
int c[5]={1,2,3,4,5,6,7,8,9,0}; //初试值设定太多 不能 成功赋值
int d[10]={}; //错误
int e[]={1,2,3,4,5}; //初值个数 等于 数组长度 可以省略数组长度
//多则报错 少则补0
//定义数组时 {}给 数组整体 赋值
数组使用
格式 数组名[下标] — 从 0 计数 5个 0 1 2 3 4
下标 可以被 改变 也是一个 变量
下标 不可越界 不能超过 所给范围
#include<stdio.h>
int main(){
int a[5]={1,2,3,4,5};
printf("%d\\n",a[2]);
a[2]=8;
printf("%d",a[2]);
}
#include<stdio.h>
int main(){
int a[5]={1,2,3,4,5};
for (int i=1;i<6;i++){
printf("%d",a[i]);
}
}
—————————-
1
2
3
4
5
二维数组
一维数组 一行多列
二维数组 多个一维数组 组合而成 多行多列
格式 数据类型 数组名[行个数][列个数]；
int a[3][8];
注意：和一维数组引用 空间一次性分配好 不可改变
行数 和 列数 要求：
行数 和 列数 必须是 常量 常量表达式 1+1 必须 正整数
int a[3][n] —–错误
二维数组初始化
格式 数据类型 数组名[行个数][列个数]={初值1,初值2,初值3,……};
二维数组赋值元素 如何分配？
将 第一个 一维数组 存储完 才会到 下一个 一维数组
先 存储 第一行列数 列数存满 到下一行列数
int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
int [0][4] //1,2,3,4
int [1][4] //5,6,7,8
int [2][4] //9,10,11,12
int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12}; //省略行个数
//先开辟一个行 行的长度 由列数 规定
//第一行列数存满 开辟下一行
//不断 存储开辟 直到所有数据 存储完毕
int a[3][4]={3}; //未赋值的元素 默认 为 0
二维数组使用
数组名[行数][列数]
#include<stdio.h>
int main(){
int a[2][5]={{0,1,2,3,4},
{5,6,7,8,9}}; //a[1][3]=8
a[1][3]= 23;
printf("%d\\n",a[1][3]);
for(int i=0;i<2;i++){
for(int j=0;j<5;j++){
printf("%d\\n",a[i][j]);
}
}
}
字符数组
一维字符数组
格式 char 数组名[];
char a[64]; //长度 不大于 64 字符串
char str1[]={'a','b','c'};
char str2[]={"abc"};
数组长度一样吗
不一样
str1 长度 为 3
str2 长度 为 4 字符串中 隐藏字符 “\\0” 结束作用
输入 字符串 到数组中 再输出
gets 和 puts s(string)字符
gets(数组名);
puts(数组名);
#include<stdio.h>
int main(){
char a[64];
gets(a);
puts(a);
}
二维字符数组
//三个名字
#include<stdio.h>
int main(){
char name[3][20];
for(int i=0;i<=2;i++){
gets(name[i]);
}
for(int i=0;i<=2;i++){
puts(name[i]);
}
}
函数
将一段有功能的代码 封装 然后 每次调用这个函数 就能实现 这个功能
函数定义
定义格式
函数返回值类型 函数名(形参列表) {
代码块
}
函数返回类型：
确定在使用后 返回什么结果 用 数据类型 确定 void–代表空白（什么都不返回）空类型
函数名：
给 封装取名 符合 标识符命名规则 —— 看见它 就知道他的 功能
(形参列表)：
( ) —- 标志 这个主体 是 函数 如果 没有 是 变量
定义几个容器 确定 个数 和 类型 void 也可以什么都不写
#include<stdio.h>
void mul(){
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
printf("%d*%d=%d\\t",i,j,i*j);
}
printf("\\n");
}
}
函数的声明与调用
声明是什么 —- 让计算机知道 这个东西的存在
声明格式： 函数返回值类型 函数名(形参列表);
调用格式： 函数名(形参列表);
函数 不能在 主函数中 定义 不能在 函数中 定义一个 函数
#include<stdio.h>
void mul();
void mul(){
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
printf("%d*%d=%d\\t",i,j,i*j);
}
printf("\\n");
}
}
int main(){
mul();
mul();
mul();
return 0;
}
函数的调用
输入两个数 比较大小 —– 函数的 参数传递
//有参数 无返回值 的调用
#include<stdio.h>
void max(int x,int y){
int z;
z=x>y?x:y;
printf("%d\\n",z);
}
int main(){
int a,b;
scanf("%d %d",&a,&b);
max(a,b);
}
//有参数 有返回值
#include<stdio.h>
int max(int x,int y){
int z;
z=x>y?x:y;
return z;
}
int main(){
int a,b;
scanf("%d %d",&a,&b);
int z=max(a,b);
printf("%d\\n",z);
}
函数的地址传递
函数传递参数时 不传递 数值 传递 地址
#include<stdio.h>
void max(int *n){
*n = *n + 10;
}
int main(){
int i=10;
max(&i);
printf("%d\\n",i);
max(&i);
printf("%d\\n",i);
max(&i);
printf("%d\\n",i);
}
指针变量
格式： 数据类型 *变量名；
作用： 保存地址
int i=10;
int *n=&i;
*n=20 // i = 20
参数传递 分两种：
值传递： 实参数值 复制一份 给 形参 但 在函数中 去改变这个值 不会影响 这个 实参原本值
地址传递 ： 将 值 复制一份 给 形参 传递改为地址值 在函数中 通过地址值 对 存储空间 也为变量 进行运算
函数的复杂调用
嵌套调用
调用一个函数时 可以去 调用 另一个函数
// ( 3 + 4 ) * 5
int add(int x,int y){
return x + y;
}
int mul(int a,int b){
return a*b;
}
int main(){
int x,y;
x=add(3,4);
y=mul(x,5);
printf("%d",y);
}
递归调用
在函数定义时 调用自己
未完待续……………………………………
gcc -o hello hello.c
