通过案例学习C++
- demo01 在屏幕上输出内容
- demo02 规格不同的箱子（变量）
- demo03 物品存放（变量赋值）
- demo04 交换物品（变量之间交换数值）
- demo05 消失的重量（隐式类型变换）
- demo06 游泳池的容量（数据类型范围示例）
- demo07 显式转换（类型转换）
- demo08 单片机应用（位操作）
- demo09 房间面积（乘法的应用）
- demo10-11 物品的分配（除法和取余的应用）
- demo12 公司组织看电影（综合）
- demo13 称水果（比较）
- demo14 简单算数（优先级）
- demo15 输出 Huffman 编码（结构+算法）
demo01 在屏幕上输出内容
案例描述：
C++的输出由cout实现。本案例演示输出不同类型的数据，包括：常量、变量及注意字符等
代码：
#include<iostream>
using namespace std;
int main() {
int i = 1; //和C语言一样，定义并初始化整型变量
cout << "欢迎来到C++的世界" << endl; //输出一个常量字符串
cout << 'a' << endl; //输出一个常量字符
cout << "i = " << i << endl; //输出一个整型变量
cout << '\n' ; //输出一个表示换行的转义字符
return 0;
}
运行结果：
代码解析：
- cout与<<匹配使用，cout输出语句中至少包含一个<<
- 常量字符串使用双引号
- 常量字符和转义字符使用单引号
- 变量不需要引号
- 如果没有第2行，则输出语句需要更改，例：
cout << ‘a’ << endl;
改为
std::cout << ‘a’ << std::endl;
demo02 规格不同的箱子（变量）
案例描述：
C++和C一样变量有多种，将数据比作箱子，看看能放多少数据
本案例演示整型和浮点型变量的表示关键字，并给出他们的界值
实现过程：
整型分为：基本整型（int）、短整型（short）、长整型（long）
浮点型分为：单精度（float）、双精度（double）、扩展双精度（long double）
声明变量后，使用cout输出它们的范围
代码：
#include<iostream>
using namespace std;
int main()
{
int i; //基本整型声明
short i1; //短整型声明
long i2; //长整型声明
float j; //单精度型声明
double k; //双精度型声明
long double k1; //扩展双精度型声明
cout << "i: " << "\t" << "(" << INT_MIN << ", " << INT_MAX << ")" << endl; //基本整型范围输出
cout << "i1:" << "\t" << "(" << SHRT_MIN << "," << SHRT_MAX << ")" << endl; //短整型范围输出
cout << "i2:" << "\t" << "(" << LONG_MIN << "," << LONG_MAX << ")" << endl; //长整型范围输出
cout << "j: " << "\t" << "(" << FLT_MIN << "," << FLT_MAX << ")" << endl; //单精度型范围输出
cout << "k: " << "\t" << "(" << DBL_MIN << "," << DBL_MAX << ")" << endl; //双精度型范围输出
cout << "k2:" << "\t" << "(" << LDBL_MIN << "," << LDBL_MAX << ")" << endl; //扩展双精度型范围输出
return 0;
}
运行结果：
代码解析：
- INT_MIN表示基本整型数据的最小值，其他一次类推
- INT_MAX表示基本整型数据的最大值，其他一次类推
- \t的使用与C语言相同
demo03 物品存放（变量赋值）
案例描述：
变量比作箱子，数据则比作数据
本案例演示如何给变量赋值
实现过程：
将数据进行初始化即正确赋值
代码：
#include<iostream>
using namespace std;
int main()
{
int i = 1; //基本整型声明
short i1 = 2; //短整型声明
long i2 = 3; //长整型声明
float j = 3.14; //单精度型声明
double k = 3.1415926; //双精度型声明
long double k1 = 3.14159265354; //扩展双精度型声明
cout << "i = " << "\t" << i << endl; //基本整型范围输出
cout << "i1 = " << "\t" << i1 << endl; //短整型范围输出
cout << "i2 = " << "\t" << i2 << endl; //长整型范围输出
cout << "j = " << "\t" << j << endl; //单精度型范围输出
cout << "k = " << "\t" << k << endl; //双精度型范围输出
cout << "k1 = " << "\t" << k1 << endl; //扩展双精度型范围输出
return 0;
}
运行结果：
demo04 交换物品（变量之间交换数值）
案例描述：
用一个临时变量交换两个变量之间的数据
实现过程：
就如两个有水的杯子，想要交换里面的水，需要拿一个临时的空杯子一样的实现过程一样
代码：
#include<iostream>
using namespace std;
int main() {
int i = 6;
int j = 9;
int temp;
cout << "交换前：" << endl << "i = " << i << endl << "j = " << j << endl;
temp = i;
i = j;
j = temp;
cout << "交换后：" << endl << "i = " << i << endl << "j = " << j << endl;
return 0;
}
运行结果：
代码解析：
- 临时变量起到一个缓冲性的作用，用于临时防止交换变量的一方
demo05 消失的重量（隐式类型变换）
案例描述：
在进行简单运算时，一般都是相同数据类型之间的运算，否则会出现数据的确实
实现过程：
定义两个不同数据类型的数据并赋初值
使两个数据做运算
输出得到的结果
代码：
#include<iostream>
using namespace std;
int main() {
float i = 0.01; //浮点型数值
int j = 6; //整型数值
int sum; //两数值求和并放入整型中
float sum2; //两数值求和并放入浮点型中
sum = i + j;
sum2 = i + j;
cout << "sum = " << sum << endl;
cout << "sum2 = " << sum2 << endl;
return 0;
}
运行结果：
代码解析：
- 被赋值的变量值必须符合其数值类型的属性特征
- 如果浮点型的小数点之后的值为0，也需要用0补齐
- 浮点型赋值给整型，则将小数点后的数据抹去
- 整型赋值为浮点型，则将小数点后添加上0
demo06 游泳池的容量（数据类型范围示例）
案例描述：
不同数据类型有不同的分为。如果超过范围则被视为越界，程序在运行时就会出现各种问题。
就如同游泳池里的水已经被加满了，如果继续加水水就会溢出。
实现过程：
为了更加直观
设置一个泳池，并设定容量——>类型的界限
设置可以循环加水，最多可以加10次。在10次之内，如果溢出则给出提示，如果不溢出则可以继续加水
代码：
#include<iostream>
using namespace std;
int main() {
int Pool_V = 0, every; //设定游泳池的容量，并设定每次加水的变量every
int count = 10;
while (count != 0) //while循环，使得可以不断加水
{
cin >> every; //与cout对应，cin是输入数据
Pool_V = Pool_V + every; //泳池里的水累计
if (Pool_V <= 100)
{
cout << "泳池内还有空间，泳池的水没有溢出，可以继续加水" << endl;
}
else
{
cout << "泳池已经被装满，请换其他泳池或者停止加水" << endl;
break;
}
count--;
}
return 0;
}
运行结果：
代码解析：
- 此处利用if……else判断是否溢出，数据类型是否溢出，系统会自动判断
- 溢出之后自动报异常
demo07 显式转换（类型转换）
案例描述：
上面说了隐式类型转换，就是计算机直接给转换
与之对应的是显式转换，就是手动强制的将数据类型给转换
显式类型转换的一般形式：（转换后的类型） 变量
实现过程：
定义两个数据，分别是整型和单精度
按照隐式转换的框架书写代码
代码：
#include<iostream>
using namespace std;
int main() {
int i = 1;
float j = 3.14;
i = (int)j; //显式类型转换
cout << "显示转换后，被赋值的i = " << i << endl;
return 0;
}
运行结果：
代码解析：
- 相比隐式类型转换，显式类型对于代码的理解更有帮助
- 可读性更强
- 更容易找出bug的问题所在
demo08 单片机应用（位操作）
案例描述：
单片机中，因为需要对电压进行控制，所以经常用到位操作。
本案例给出位操作的实际结果
计算机中数据的存储都是二进制的
手动按位运算，是将十进制数字化为二进制，然后对每一位进行操作
实现过程：
定义两个整型变量
对两个变量进行位操作
对单个变量进行位取反、左移、右移
用cout输出结果，更加直观
代码：
#include<iostream>
using namespace std;
int main() {
int a = 10;
int b = 2;
int c;
c = a & b;
cout << "a 和 b 按位 与 之后的结果为：" << c << endl;
c = a | b;
cout << "a 和 b 按位 或 之后的结果为：" << c << endl;
c = a ^ b;
cout << "a 和 b 按位 异或 之后的结果为：" << c << endl;
c = ~a;
cout << "a 按位 取反 之后的结果为：" << c << endl;
c = a << 1;
cout << "a 向左移动以为 之后的结果为：" << c << endl;
c = a >> 1;
cout << "a 向右 之后的结果为：" << c << endl;
return 0;
}
运行结果：
代码解析：
- 对于有符号的数据，在进行右移操作时，可以先试用变量试验并了解当前的编译系统对于有右移操作的规律。
| 符号 | 描述 | 规则 |
|---|---|---|
| & | 与 | 两个位都为1时，结果才为1 |
| | | 或 | 两个位都为0时，结果才为0 |
| ^ | 异或 | 两个位相同为0，相异为1 |
| ~ | 取反 | 0变1，1变0 |
| << | 左移 | 各二进位全部左移若干位，高位丢弃，低位补0 |
| >> | 右移 | 各二进位全部右移若干位，对无符号数，高位补0，有符号数 各编译器处理方法不一样，有的补符号位（算术右移），有的补0（逻辑右移） |
demo09 房间面积（乘法的应用）
案例描述：
C++的乘法与C语言中的乘法是一样的，所以在这里简单给出其应用
实现过程：
定义三个变量——长、宽、面积
终端输入长、宽的值
计算出面积的值
输出结果
代码：
#include<iostream>
using namespace std;
int main() {
float width;
float length;
float area;
cin >> width >> length;
area = width * length;
cout << "房间的面积为：" << area << endl;
return 0;
}
运行结果：
demo10-11 物品的分配（除法和取余的应用）
案例描述：
C++的乘法与C语言中的除法和取余是一样的，所以在这里简单给出其应用
在这里用简单的幼儿园老师分苹果的例子来描述
实现过程：
案例中给出苹果的总数和人数，同样，这两个数值可以根据需要，利用cin进行终端输入
计算每个人能分多少，还会剩余多少
在分配之前，要先确定人数是不是等于0，因为在除法计算中，除数不能为0
代码：
#include<iostream>
using namespace std;
int main() {
int apple;
int child;
int per,remain;
//终端输入apple数目和人数
cout << "请输入苹果的总数：";
cin >> apple;
cout << "请输入总人数：";
cin >> child;
cout << "苹果的总数为：" << apple << endl;
cout << "人数：" << child;
if (child != 0)
{
per = apple / child;
remain = apple % child; //取余
if (remain != 0)
{
cout << "苹果无法平均分配，每个人分到（" << per << ")个苹果，还剩下（" << remain << ")个苹果。" << endl;
}
else
{
cout << "苹果可以平均分配，每个人平均分到苹果的个数为：" << per << endl;
}
}
else
{
cout << "除数等于0，输入异常" << endl;
}
}
运行结果：
代码解析：
- 一旦遇到除法运算，一定要先判断除数是否为0
- 在没有判断的情况下就直接运算可能会导致程序出错
- 取余和除法的原理是一样的，也需要进行贩毒案取余数是否为0
demo12 公司组织看电影（综合）
案例描述：
公司预支 1000 元给 8 名员工去看电影，其中 4 男 4 女。
电影院实行优惠政策，男士票为全价，而女士票为半价。
现已知一张电影票的全价为 35 元，则最后还剩多少钱？所剩的钱最多能让几位男士看电影？
实现过程：
首先声明 8 个变量，sum 用于表示资金总额，male 和 female 分别表示男女员工的人数
ticket_male 和 ticket_female 分别表示每个男女员工看电影需花多少钱，remain 表示
还剩多少钱，male_num 表示剩余的钱还够几个男员工观看电影，
代码：
#include<iostream>
using namespace std;
int main() {
float sum = 1000.0;
int male = 4;
int female = 4;
float full_ticket_value = 35.0;
float ticket_male = full_ticket_value;
float ticket_female = full_ticket_value / 2;
float remain;
remain = sum - (male * ticket_male + female * ticket_female);
cout << "还剩下：" << remain << "元" << endl;
int male_num = (int)remain / ticket_male;
cout << "剩余的钱可以让：" << male_num << "位男士看电影" << endl;
return 0;
}
运行结果：
代码解析：
- 此案例中，结合了之前所有的案例
- 为了代码的可动性更强，这里算这里使用了显式转换
demo13 称水果（比较）
案例描述：
生活中的大部分时间，习惯性的会四舍五入
此案例以买水果为例子，展现四舍五入
实现过程：
输入水果重量
判断是小于0.5，还是不小于0.5
小于0.5，直接舍去，在程序中，可以利用显式转换直接取整的方式，将小数点后的数据舍去
大于等于0.5则可以利用小于0.5的步骤再加一
代码：
#include<iostream>
using namespace std;
int main() {
float fruit_weight;
int fruit_weight_cal;
cout << "请输入水果的重量：" << endl;
cin >> fruit_weight;
int sub;
sub = fruit_weight - (int)fruit_weight;
if (sub < 0.5)
{
fruit_weight_cal = (int)fruit_weight;
}
else
{
fruit_weight_cal = (int)fruit_weight + 1;
}
cout << "需要被付钱的水果一共" << fruit_weight_cal << "斤" << endl;
return 0;
}
运行结果：
demo14 简单算数（优先级）
案例描述：
C++中有很多运算符，包括赋值运算符、算术运算符、逻辑运算符、关系运算符。对于这些运算符在参与运算时，并不是按照从左到右开始运算，每个运算符都有各自的优先级。优先级较高的先于优先级低的进入运算。
实现过程：
本实例利用函数 int level(char ch)判断输入运算符的级别，它的返回值为输入运算符的级别数值。
char symbol[3]用于存储输入的运算符，int value[3]用于存储输入运算符的优先级。
利用swich进行选择匹配，并以整数的形式返回优先级
代码：
#include<iostream>
using namespace std;
int level(char ch) {
switch (ch)
{
case '!':
return 2;
break;
case '*':
return 3;
break;
case '/':
return 3;
break;
case '%':
return 3;
break;
case '+':
return 4;
break;
case '-':
return 4;
break;
case '=':
return 5;
break;
default:
return -1;
break;
}
}
int main() {
char symbol[3];
int value[3];
cout << "从 ！、 * 、 / 、% 、+ 、- 、= 运算符中选择3个参与算术运算 " << endl;
cin >> symbol[0] >> symbol[1] >> symbol[2];
value[0] = level(symbol[0]);
value[1] = level(symbol[1]);
value[2] = level(symbol[2]);
if (value[0] == -1 || value[1] == -1 || value[2] == -1) //只要有一个返回负数则直接报出警告，没有该种运算符
{
cout << "库中没有输入发运算符！" << endl;
}
else
{
//从大到小排序
for (int i = 0; i < 3; i++)
{
for (int j = i; j < 3; j++) //如果前一个大于后一个，开始交换
{
if (value[i] > value[j])
{
//demo04中的交换，只不过这个是char类型的交换
char temp;
temp = symbol[i];
symbol[i] = symbol[j];
symbol[j] = temp;
}
}
}
cout << "依次进入计算的顺序为：" << endl;
for (int i = 0; i < 3; i++)
{
cout << symbol[i] << endl;
}
}
return 0;
}
运行结果：
代码解析：
- 本案例是使用的冒泡排序法
- 将数组的数据利用冒泡排序法从大到小排序
- 可以节约算法的时间
demo15 输出 Huffman 编码（结构+算法）
案例描述：
实例演示如何输出 Huffman 编码。
实现过程：
需要结构体的参与
统计字符串中出现字符的频率
该功能的实现形成一种现成的算法，以简单地实现 Huffman 编码的获取
三部分：头文件的包含、结构体的定义、函数 coding()的实现
代码：
#include<iostream>
using namespace std;
struct huffTree {
int parent; //父亲
int l_child; //左孩子
int r_child; //右孩子
int weight; //权重
string flag; //标志
};
struct Lowest_Node //第 0 级节点的字符与频度
{
char ch;
int ch_num;
};
void coding(int length, huffTree tree[], int n, int& a, int& b)
{
int i;
int r, s;
r = s = length; //节点个数最大不会超过字符串的长度
for (i = 0; i < n; i++)
{
if ((tree[i].weight < r) && (tree[i].parent == -1))
{
r = tree[i].weight;
a = i;
}
}
for (i = 0; i < n; i++)
{
if ((tree[i].weight < s) && (i != a) && (tree[i].parent == -1))
{
s = tree[i].weight;
b = i;
}
}
}
void frequency(string str) {
int length = str.length(); //长度
Lowest_Node* node = new Lowest_Node[length]; //声明最 0 级节点
int i, j; //循环因子
for (int i = 0; i < length; i++)
{
node[i].ch_num = 0; //初始化频度
}
int char_type_num = 0; //初始为 0 种字符
for (int i = 0; i < length; i++) //循环整个字符串
{
for (j = 0; j < char_type_num; j++) {
if (str[i] == node[j].ch ||(node[j].ch >= 'a' && node[j].ch <= 'z' && str[i] + 32 == node[j].ch)) //该字符没有出现过，跳出循环
{
break;
}
}
if (j < char_type_num) //字符重复出现对应记数器加 1
{
node[j].ch_num++;
}
else //新出现的字符，记录到 ch[j]中，对应计数器加 1
{
if (str[i] >= 'A' && str[i] <= 'Z')
node[j].ch = str[i] + 32;
else
node[j].ch = str[i];
node[j].ch_num++;
char_type_num++; //字符的种类数加 1
}
}
//按频度从大到小排序
for (int i = 0; i < char_type_num; i++)
{
for (j = i; j < char_type_num; j++) {
if (node[j].ch_num < node[j+1].ch_num) //如果前一个小于后一个，交换
{
int temp; //临时频度
char ch_temp; //临时字符
temp = node[j].ch_num;
ch_temp = node[j].ch;
node[j].ch_num = node[j + 1].ch_num;
node[j].ch = node[j + 1].ch;
node[j + 1].ch_num = temp;
node[j + 1].ch = ch_temp;
}
}
}
for (int i = 0; i < char_type_num; i++) //打印字符频度
{
cout << "字符" << node[i].ch << "出现了" << node[i].ch_num << "次" << endl;
}
huffTree* huff = new huffTree[2 * char_type_num - 1]; //此变量的声明需位于确定 char_type_num 值后
huffTree temp;
string* code = new string[2 * char_type_num - 1]; //存放各个字符的编码
for (int i = 0; i < 2* char_type_num; i++) //节点初始化
{
huff[i].l_child = -1;
huff[i].parent = -1;
huff[i].r_child = -1;
huff[i].flag = -1;
}
for (int i = 0; i < char_type_num; i++) //将排序后的第 0 级节点权重赋给树节点
{
huff[j].weight = node[j].ch_num;
}
int min1, min2;
for (int k = char_type_num; k < 2 * char_type_num - 1; k++) //赋值 0 级之上的节点
{
coding(length, huff, k, min1, min2);
huff[min1].parent = k;
huff[min2].parent = k;
huff[min1].flag = "0";
huff[min2].flag = "1";
huff[k].l_child = min1;
huff[k].r_child = min2;
huff[k].weight = huff[min1].weight + huff[min2].weight;
}
for (int i = 0; i < char_type_num; i++)
{
temp = huff[i];
while (1)
{
code[i] = temp.flag + code[i];
temp = huff[temp.parent];
if (temp.parent == -1)
break;
}
}
cout << "字符串的每个字符 huffman 编码为:" << endl;
for (i = 0; i < char_type_num; i++)
cout << node[i].ch << " " << code[i] << endl;
cout << "整个字符串的 huffman 编码为：" << endl;
for (i = 0; i < length; i++)
{
for (j = 0; j < char_type_num; j++)
{
if (str[i] == node[j].ch)
cout << code[j];
}
}
//释放内存
delete[] node;
node = NULL;
delete[] huff;
huff = NULL;
delete[] code;
code = NULL;
}
int main() {
int length; //字符串长度
string str; //目标字符串
cout << "请输入一个字符串：" << endl;
cin >> str;
frequency(str); //求各个元素的频度
return 0;
}
运行结果：
代码解析：
- 利用 new 为数组申请，必须在最后用 delete 释放。
![Melis4.0[D1s]:7.lvgl添加物理按键](https://img-blog.csdnimg.cn/db6f40a87d174126897272b97f92a4de.gif#pic_center)
