yu/24_grade_C
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

third lesson

Browse Source
This commit is contained in:
y1143597749 2025-03-07 12:21:06 +08:00
parent 611314db2f
commit 1ca2875458
4 changed files with 383 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
d Normal file
View File

@ -0,0 +1,27 @@
diff.astextplain.textconv=astextplain
filter.lfs.clean=git-lfs clean -- %f
filter.lfs.smudge=git-lfs smudge -- %f
filter.lfs.process=git-lfs filter-process
filter.lfs.required=true
http.sslbackend=schannel
core.autocrlf=true
core.fscache=true
core.symlinks=true
pull.rebase=false
credential.helper=manager
credential.https://dev.azure.com.usehttppath=true
init.defaultbranch=master
init.defaultbranch=master
user.email='1143597749@qq.com'
user.name='y1143597749'
credential.helperselector.selected=manager
credential.https://git.smallkun.cn.provider=generic
https.proxy=http://127.0.0.1:10808
http.proxy=http://127.0.0.1:10808
core.repositoryformatversion=0
core.filemode=false
core.bare=false
core.logallrefupdates=true
core.ignorecase=true
remote.origin.url=https://git.smallkun.cn/yu/24_grade_C.git
remote.origin.fetch=+refs/heads/*:refs/remotes/origin/*

32
笔记/第一课 作业解析.md Normal file
View File

@ -0,0 +1,32 @@
1.编写一个程序，输出一个勾的图案
```c
#include <stdio.h>
int main() {
printf(" *\n");
printf(" * \n");
printf("* * \n");
printf(" * * \n");
printf(" * \n");
return 0;
}
```
2.编写一个程序，输入两个整数，计算加减乘除后的结果
```c
#include <stdio.h>
int main() {
int a;
int b;
scanf("%d%d", &a, &b);
printf("%d + %d = %d\n", a, b, a + b);
printf("%d - %d = %d\n", a, b, a - b);
printf("%d * %d = %d\n", a, b, a * b);
printf("%d / %d = %d\n", a, b, a / b);
return 0;
}
```

34
笔记/第三课 作业解析.md Normal file
View File

@ -0,0 +1,34 @@
作业1.输入长方形的长和宽两个数字，可以是小数，计算长方形的周长和面积。
```c
#include <stdio.h>
int main() {
double chang, kuan;
double zhouchang, mianji;
printf("请输入长方形的长和宽：");
scanf("%lf%lf", &chang, &kuan);
zhouchang = (chang + kuan) * 2;
mianji = chang * kuan;
printf("长方形的周长为：%lf \n", zhouchang);
printf("长方形的面积为：%lf \n", mianji);
return 0;
}
```
作业2.编写一个程序，输入一个小写英文字母，将这个字符转换为大写。
```c
#include <stdio.h>
int main() {
char c;
printf("请输入一个小写的英文字母：");
scanf("%c", &c);
printf("%c \n", c - 32); // 每个大写字母ASCII码和其对应的小写字母ASCII码相差32
return 0;
}
```

290
笔记/第三课.md Normal file
View File

@ -0,0 +1,290 @@
# 知识点
#### **1. 变量类型及其占用空间**
在C语言中，变量类型决定了变量可以存储的数据范围以及占用的内存空间大小。以下是四种常见变量类型的详细信息：
| 变量类型 | 占用空间 | 数据表示范围 | 说明 |
| :------- | :------- | :-------------------------------- | :----------------------------------------------------------- |
| `int` | 4字节 | -2,147,483,648 到 2,147,483,647 | 用于存储整数，范围约为 -21亿 到 +21亿。 |
| `float` | 4字节 | 约 ±3.4e-38 到 ±3.4e+38 | 单精度浮点数，可存储小数，但精度有限（约6-7位有效数字）。 |
| `double` | 8字节 | 约 ±1.7e-308 到 ±1.7e+308 | 双精度浮点数，可存储更大范围和更高精度的小数（约15位有效数字）。 |
| `char` | 1字节 | -128 到 127 或 0 到 255（无符号） | 用于存储单个字符，通常表示ASCII码（0-127）。 |
#### **2.数据表示范围的限制**
- **`int` 类型**：
- 范围有限，超出范围会导致溢出。例如：
```c
int a = 2147483647; // int 的最大值
a = a + 1; // 溢出，结果未定义
```
- 解决方法：使用更大范围的类型（如 `long long`）。
- **`char` 类型**：
- 只能表示有限数量的字符（ASCII码为0-127）。
- 如果需要表示更多字符（如中文），可以使用多字节编码（如UTF-8）。
- **浮点数类型**：
- `float` 和 `double` 虽然可以表示小数，但精度有限。
- 例如：
```c
float f = 0.1f;
printf("%.20f\n", f); // 输出 0.10000000149011611938（精度损失）
```
#### **3. 类型转换**
在C语言中，类型转换分为两种：**隐式类型转换** 和 **强制类型转换**。
##### **（1）隐式类型转换**
- 编译器自动进行的类型转换，通常发生在不同类型的数据进行运算时。
- 规则：将低精度类型转换为高精度类型（如 `int` → `double`）。
- 示例：
```c
int i1 = 5, i2 = 2;
double d = 1.0 * i1 / i2; // 隐式将 i1 和 i2 转换为 double 类型
printf("隐式类型转换后的值为: %lf\n", d); // 输出 2.500000
```
##### **（2）强制类型转换**
- 程序员手动指定类型转换，使用 `(目标类型)` 语法。
- 示例：
```
int i1 = 5, i2 = 2;
double d = (double)i1 / i2; // 强制将 i1 转换为 double 类型
printf("强制类型转换后的值为: %lf\n", d); // 输出 2.500000
```
------
#### **4. 示例代码**
以下代码演示了类型转换的使用场景：
```c
#include <stdio.h>
int main() {
int i1 = 5, i2 = 2;
double d;
// 未进行类型转换
d = i1 / i2; // 结果为 2.000000（小数部分被丢弃）
printf("未进行类型转换的值为: %lf\n", d);
// 强制类型转换
d = (double)i1 / i2; // 将 i1 转换为 double 类型
printf("强制类型转换后的值为: %lf\n", d);
// 隐式类型转换
d = 1.0 * i1 / i2; // 通过 1.0 触发隐式转换
printf("隐式类型转换后的值为: %lf\n", d);
return 0;
}
```
**输出结果**：
```
未进行类型转换的值为: 2.000000
强制类型转换后的值为: 2.500000
隐式类型转换后的值为: 2.500000
```
变量类型占用的空间有限，那么使用时，数据的表示范围也就有限，例如int类型数据表示范围是**-21亿到+21亿**，而char字符只占一个字节，理论上能表示256种数据，足够表示ASCII码的128个字符。
之前我们在做运算时，会发现两个整数相除，小数位会被自动丢弃掉，那如果我们不想丢弃小数，就只能使用类型转换了，将整数类型给他转换为小数类型。
类型转换分为强制类型转换和隐式类型转换，下面用代码方式演示
```c
#include <stdio.h>
int main() {
int i1 = 5, i2 = 2;
double d;
d = i1 / i2;
printf("没有进行类型转换的值为:%lf\n", d);
d = (double)i1 / i2; // 在变量名前写上想要转换的类型，即可转换为该类型
printf("强制类型转换后的值为:%lf\n", d);
d = 1.0 * i1 / i2;
printf("隐式类型转换后的值为:%lf\n", d);
return 0;
}
```
#### **5. 注意事项**
1. **精度损失**：
- 强制类型转换可能导致精度损失，尤其是从高精度类型转换为低精度类型时。
- 例如：
```c
double d = 3.14;
int i = (int)d; // i 的值为 3（小数部分丢失）
```
2. **溢出问题**：
- 当数据超出目标类型的表示范围时，会导致溢出。
- 例如：
```c
int i = 2147483647; // int 的最大值
i = i + 1; // 溢出，结果未定义
```
3. **隐式转换的陷阱**：
- 隐式转换可能导致意外的结果，尤其是在混合类型运算时。
- 例如：
```c
int i = 5;
float f = i / 2; // f 的值为 2.000000（未触发隐式转换）
```
------
#### **6. 总结**
- **变量类型**决定了数据的表示范围和占用空间。
- **类型转换**分为隐式转换和强制转换，用于在不同类型之间进行数据转换。
- 使用类型转换时，需注意精度损失和溢出问题。
# 练习
```
1.
输入如下格式数据
(404) 817-6900
转换成如下格式输出
404.817.6900
```
```c
#include <stdio.h>
int main() {
int a, b, c;
scanf("(%d) %d-%d", &a, &b, &c);
printf("%d.%d.%d", a, b, c);
return 0;
}
```
```
2.
计算两个分数相加的结果，结果无需约分
输入
5/6+3/4
输出
38/24
```
```c
#include <stdio.h>
int main() {
int a, b, c, d;
int fenzi, fenmu;
scanf("%d/%d+%d/%d", &a, &b, &c, &d);
fenzi = a * d + b * c;
fenmu = b * d;
printf("%d/%d", fenzi, fenmu);
return 0;
}
```
```
3.
输入一个数字x，代表需要支付的钱数，现有100元，20元，5元，1元纸币若干张，想要使用最少的纸币去结清账款，请你计算怎么付，可以让付出去的纸币数量最少
输入
256
输出
付了2张100元，还需要支付56元
付了2张20元，还需要支付16元
付了3张5元，还需要支付1元
付了1张1元，支付完成
```
```c
#include <stdio.h>
int main() {
int x; // 需要支付的钱款数额
int a100, a20, a5, a1; // a100代表100元纸币需要多少张，依次类推
printf("请输入：");
scanf("%d", &x);
a100 = x / 100; // 通过除以100来计算需要付多少100张的纸币，并且C语言中，整数相除可以自动舍弃小数
x = x % 100; // 计算余数，看付完100元的纸币后，接下来还需要付多少钱
printf("付了%d张100元，还需要支付%d元\n", a100, x);
a20 = x / 20;
x %= 20; // 简写方式，等同于 x = x % 20;
printf("付了%d张20元，还需要支付%d元\n", a20, x);
a5 = x / 5;
x %= 5;
printf("付了%d张5元，还需要支付%d元\n", a5, x);
printf("付了%d张1元，支付完成\n", x);
return 0;
}
```
```
4.
编写一个程序，输入一个四位数，分别取出他的个十百千位上的数字
输入
1234
输出
```
```c
#include <stdio.h>
int main() {
int x;
int ge, shi, bai, qian;
printf("请输入：");
scanf("%d", &x);
// 直接除10，取得的余数就是个位的
ge = x % 10;
// 除以10，将十位上的数移动到个位上，然后取余10，就可以拿到十位上的数
shi = x / 10 % 10;
// 先取余1000可以理解为干掉千位以上的数，留下的三位数，在除100，干掉后面两位数
bai = x % 1000 / 100;
// 除1000，直接干掉个十百位数，剩下的就是千位了
qian = x / 1000;
printf("个位上的数为：%d\n", ge);
printf("十位上的数为：%d\n", shi);
printf("白位上的数为：%d\n", bai);
printf("千位上的数为：%d\n", qian);
return 0;
}
```