一、常量

01. 常量的定义：符号常量

① 实型常量

② 整型常量

扫描二维码关注公众号，回复： 16793794 查看本文章

① 占位符 “%d” 改为格式说明符 “%llu”

② 占位符 “%d” 改为格式说明符 “%f” 或 “%e”

13. 变量：字节数统计

14. 变量：浮点数 float 的最小/大值

一、常量

01. 常量的定义：符号常量

① 实型常量

#define P1 3.14159    /* 定义符号常量 P1, 其值等于实型常量 3.14159 */

② 整型常量

#define N 10          /* 定义符号常量 N, 其值等于整型常量 10 */

③ 字符常量

#define M 'm'         /* 定义符号常量 M, 其值等于字符常量 m */

02. 常量的定义：有名常量

① 整型有名常量

const int j=1, k=2;    /* 定义 2 个整型有名常量, j 的值是 1, k 的值是 2 */

② 单精度实型有名常量

const float f1=3.5, f2=6.8;  /* 定义 2 个单精度实型有名常量，f1 的值是 3.5，f2 的值是 6.8 */

③ 字符型有名常量

const char chl='Y', ch2='N';  /* 定义 2 个字符型有名常量，chl 和 ch2 的值分别是字符 Y 和字符 N */

03. 字符常量：分数与排名

【示例代码】
#include <iostream>

#define CHINESE_SCORE 88 // 宏定义语文成绩的整型常量
#define MATH_SCORE 90.5 // 宏定义数学成绩的实型常量
#define ENGLISH_SCORE 95 // 宏定义英语成绩的整型常量
#define CLASS_RANK "第 19 名" // 宏定义全班排名的字符常量

int main() {
    std::cout << "小茗同学的成绩：" << std::endl;
    std::cout << "语文成绩：" << CHINESE_SCORE << std::endl;
    std::cout << "数学成绩：" << MATH_SCORE << std::endl;
    std::cout << "英语成绩：" << ENGLISH_SCORE << std::endl;
    std::cout << "全班排名：" << CLASS_RANK << std::endl;

    return 0;
}
【代码详解】

这段代码是一个使用宏定义符号常量的 C++ 程序，用于输出小茗同学的成绩以及他在全班的排名。

使用宏定义符号常量，分别定义了小茗同学的语文、数学和英语成绩以及全班排名。其中，全班排名使用字符常量 "第 19 名" 进行定义。

在主函数 main() 中使用 std::cout 输出小茗同学的成绩和全班排名。

【输出结果】
小茗同学的成绩：
语文成绩：88
数学成绩：90.5
英语成绩：95
全班排名：第 19 名

04. 有名常量：价格统计

【示例代码】
#include <iostream>

int main() {
    const float APPLE_PRICE = 3.5; // 定义常量，单个苹果价格为3.5元
    const int NUM_APPLES = 30; // 定义常量，苹果的数量为30个

    float totalCost = APPLE_PRICE * NUM_APPLES; // 计算总花费

    std::cout << "苹果的价格：" << APPLE_PRICE << " 元" << std::endl;
    std::cout << "苹果的数量：" << NUM_APPLES << " 个" << std::endl;
    std::cout << "总花费：" << totalCost << " 元" << std::endl;

    return 0;
}
【代码详解】

定义了两个常量，分别是 APPLE_PRICE 和 NUM_APPLES，它们的值分别为 3.5 和 30。使用 const 关键字表示这些变量是不可修改的常量。

使用了一个 float 类型变量 totalCost 来保存总花费，它的值等于苹果单价乘以苹果数量。

使用了 std::cout 来输出结果。std::cout 用于输出到控制台。

【输出结果】
苹果的价格：3.5 元
苹果的数量：30 个
总花费：105 元

05. 有名常量：平均分

【示例代码】
#include <iostream>

int main() {
    const int NUM_STUDENTS = 5; // 定义常量，学生数量为5
    
    // 定义学生的数学分数
    const int mathScores[NUM_STUDENTS] = {13, 24, 57, 80, 90};
    
    int totalScore = 0; // 总分数
    
    // 遍历数组，计算总分数
    for (int i = 0; i < NUM_STUDENTS; ++i) {
        totalScore += mathScores[i];
    }
    
    float averageScore = static_cast<float>(totalScore) / NUM_STUDENTS; // 计算平均分数
    
    std::cout << "学生的数学分数：" << std::endl;
    // 输出学生的数学分数
    for (int i = 0; i < NUM_STUDENTS; ++i) {
        std::cout << "学生" << i + 1 << "的分数：" << mathScores[i] << std::endl;
    }
    
    std::cout << "平均分数：" << averageScore << std::endl;

    return 0;
}
【代码详解】

定义了一个有名常量 NUM_STUDENTS，表示学生的数量为 5。

定义了一个整型数组 mathScores 来存储学生的数学分数，使用了花括号初始化列表将分数赋值给数组。数组的大小为 NUM_STUDENTS，这样可以确保数组可以容纳下全部学生的分数。

定义了一个整型变量 totalScore 来保存总分数，初始值为 0。

使用一个循环遍历数组，计算总分数。

使用 static_cast<float>(totalScore) 将总分数转换为浮点型，然后除以学生的数量NUM_STUDENTS，得到平均分数。

使用循环输出每个学生的数学分数。

最后输出平均分数。

【输出结果】
学生的数学分数：
学生1的分数：13
学生2的分数：24
学生3的分数：57
学生4的分数：80
学生5的分数：90
平均分数：52.8

二、变量

01. 变量的定义：有符号整型变量

① 有符号基本整型变量

int radius, area;     /* 定义 2 个有符号基本整型变量，变量名分别是 radius 和 area */

② 有符号短整型变量

short m, n;           /* 定义 2 个有符号短整型变量，变量名分别是 m 和 n */

③ 有符号长整型变量

long a1, a2;          /* 定义 2 个有符号长整型变量，变量名分别是 a1 和 a2 */

02. 变量的定义：无符号整型变量

① 无符号基本整型变量

unsigned i, j, k;      /* 定义 3 个无符号基本整型变量，变量名分别是 i, j 和 k */

unsigned int x, y;     /* 定义 2 个无符号基本整型变量，变量名分别是 x 和 y */

② 无符号短整型变量

unsigned short s1, s2;  /* 定义 2 个无符号短整型变量，变量名分别是 s1 和 s2 */

③ 无符号长整型变量

unsigned long r;        /* 定义 1 个无符号长整型变量，变量名是 r */

03. 变量的定义：实型变量

① 单精度实型变量

float radius, area;    /* 定义 2 个单精度实型变量，变量名分别是 radius 和 area*/

② 双精度实型变量

double fl, f2;         /* 定义 2 个双精度实型变量，变量名分别是 fl 和 f2*/

04. 变量的定义：字符型变量

① 字符型变量

char ch1, ch2;        /* 定义 2 个字符型变量，变量名分别是 ch1 和 ch2 */

05. 变量的初始化：有符号整型变量

① 有符号基本整型变量

int radius=2, area;    /* 定义 2 个有符号基本整型变量，radius 赋初值为 2, area 无初值 */

② 有符号短整型变量

short m=1, n=2;           /* 定义 2 个有符号短整型变量，m 和 n 分别赋初值为 1 和 2 */

③ 有符号长整型变量

long a1=123R, a2;          /* 定义 2 个有符号长整型变量，a1 赋初值为 123R, a2 无初值 */

06. 变量的初始化：无符号整型变量

① 无符号基本整型变量

unsigned i=1, j, k;      /* 定义 3 个无符号基本整型变量，i 赋初值为 1, j 和 k 无初值 */

unsigned int x, y=0;     /* 定义 2 个无符号基本整型变量，x 无初值，y 赋初值为 0 */

② 无符号短整型变量

unsigned short s1=1, s2;  /* 定义 2 个无符号短整型变量，s1 赋初值为 1，s2 无初值 */

③ 无符号长整型变量

unsigned long r=100;        /* 定义 1 个无符号长整型变量，r 赋初值为 100 */

07. 变量的初始化：实型变量

① 单精度实型变量

float radius=2.5, area=0.0;  /* 定义 2 个单精度实型变量，radius 赋初值为 2.5, area 赋初值为 0.0 */

② 双精度实型变量

double fl=1.234, f2=5.6E2;  /* 定义 2 个双精度实型变量，fl 赋初值为 1.234, f2 赋初值为 5.6E2 */

08. 变量的初始化：字符型变量

① 字符型变量

char ch1='Y', ch2='N';        /* 定义 2 个字符型变量，ch1 赋初值为字符 Y,ch2 赋初值为
字符 N */

09. 变量：定义

未定义变量，直接引用变量时：

出现报错：未定义标识符 "a"

解决报错：先定义变量

10. 变量：初始化

只定义变量，未初始化变量时，引用变量时：

出现报错：C6001: 使用未初始化的内存 "a"。

解决报错：定义变量时，同时初始化变量

11. 变量：参数传递

已定义变量，并初始化变量时，传递变量参数时：

出现报错：C6271: 传递给 "printf" 的额外参数

解决报错：使用占位符 “%d”，需注意传递的参数不能超过格式字符串中占位符的数量

【报错解决详解】

当在调用 printf 函数时，如果传递的参数超过了格式字符串中占位符的数量，就会出现 C6271 错误，这个错误是指传递给 printf 的额外参数：
例如，假设定义了一个整数变量 num 并初始化为 10，然后想将其打印出来，以下是一个正确的示例，因为格式字符串 "%d" 中有一个占位符 %d 来接收整数参数 num 的值，正确代码如下所示：
int num = 10;
printf("Number: %d\n", num);
然而，如果在格式字符串中只有一个占位符 %d，但传递了多个参数给 printf，就会触发 C6271 错误，下述代码中，传递了两个参数 num 和 20 给 printf 函数，但是在格式字符串中只有一个 %d 占位符。这就导致了额外的参数无法被正确处理，从而引发了错误，错误代码如下所示：
int num = 10;
printf("Number: %d\n", num, 20);
为了解决这个问题，需要确保传递给 printf 函数的参数的数量与格式字符串中的占位符的数量一致，或者确保占位符的数量与要打印的参数的数量相匹配。例如，如果想将两个整数打印出来，需要使用两个占位符 %d，这样就不会触发 C6271 错误了，正确代码如下所示：
int num1 = 10;
int num2 = 20;
printf("Numbers: %d, %d\n", num1, num2);

12. 变量：格式说明符

① 占位符 “%d” 改为格式说明符 “%llu”

已定义变量，并初始化变量时，传递变量参数时：

出现报错：C6328: 大小不匹配: 已将 “unsigned _ _int64" 作为 _Param_(2) 传递，但需要使用 "int" 来调用 "printf"。

解决报错：解决参数类型不匹配错误，修改 “%d” 为 “%llu”，使用 %llu 格式说明符来与 unsigned __int64 类型匹配，其中 llu 表示无符号长整型数。

【报错解决详解】
C6328 错误是由于参数类型不匹配引起的。

在代码中，sizeof(int) 返回一个 unsigned __int64 类型的值，但是传递给 printf 函数的格式字符串中使用了 %d，这会导致参数类型不匹配错误。

为了解决这个问题，可以使用 %llu 格式说明符来与 unsigned __int64 类型匹配，其中 llu 表示无符号长整型数。
以下是修正后的代码：
#include <stdio.h>

int main()
{
	int a = 0;
	float b = 0;
	double c = 0;

	printf("变量名（中文）：%d\n", a);
	printf("变量值（数字）：%llu\n" , sizeof(int));
}
修复后，printf 函数的参数类型与格式说明符 %llu 相匹配，因此就不会触发 C6328 错误了。

② 占位符 “%d” 改为格式说明符 “%f” 或 “%e”

已定义变量，并初始化变量时，传递变量参数时：

出现报错：C6273: 调用 "printf" 实际类型: "double" 时需要整数时，非整数传递为_Param_(2)。

解决报错：解决参数类型不匹配错误，修改占位符 “%d” 改为 “%f” 或 “%e” 来打印 FLT_MIN 和 FLT_MAX，这两个值是浮点类型的，而不是整型，应该使用 %f 或 %e 格式说明符来打印浮点数

【报错解决详解】

报错信息提示的问题出现在以下两行代码：

printf("打印浮点数 float 的最小值：%d\n", FLT_MIN);
printf("打印浮点数 float 的最大值：%d\n", FLT_MAX);

错误原因是使用错误的格式说明符 %d 来打印 FLT_MIN 和 FLT_MAX，这两个值是浮点类型的，而不是整型。应该使用 %f 或 %e 格式说明符来打印浮点数。

修改后的代码中，使用 %f 替代 %d 格式说明符来打印浮点数 FLT_MIN 和 FLT_MAX，从而解决了格式化输出的错误。修改后的代码如下：

#include<stdio.h>
#include <cfloat>

int main()
{
    int a = 0;                           // 定义并初始化整型变量 a
    float b = 1.5;                       // 定义并初始化浮点型变量 b
    double c = 5.78;                     // 定义并初始化双精度浮点型变量 c

    /* 参数传递 */
    printf("打印变量 a 的值：%d\n", a);  // 打印变量 a 的值，使用 %d 格式说明符打印整型值

    /* 字节数统计 */
    printf("打印 int 的字节数：%llu\n", sizeof(int));     // 使用 sizeof 运算符获取 int 类型的大小并使用 %llu 格式说明符打印无符号长整型值
    printf("打印 float 的字节数：%llu\n", sizeof(float));   // 使用 sizeof 运算符获取 float 类型的大小并使用 %llu 格式说明符打印无符号长整型值
    printf("打印 double 的字节数：%llu\n", sizeof(double)); // 使用 sizeof 运算符获取 double 类型的大小并使用 %llu 格式说明符打印无符号长整型值

    /* 浮点数的最小/大值 */
    printf("打印浮点数 float 的最小值：%f\n", FLT_MIN);
    printf("打印浮点数 float 的最大值：%f\n", FLT_MAX);

    return 0;
}

13. 变量：字节数统计

【示例代码】
#include<stdio.h>

int main()
{
    int a = 0;                           // 定义并初始化整型变量 a
    float b = 1.5;                       // 定义并初始化浮点型变量 b
    double c = 5.78;                     // 定义并初始化双精度浮点型变量 c

    /* 参数传递 */
    printf("打印变量 a 的值：%d\n" , a);  // 打印变量 a 的值，使用 %d 格式说明符打印整型值
    
    /* 字节数统计 */
    printf("打印 int 的字节数：%llu\n" , sizeof(int));     // 使用 sizeof 运算符获取 int 类型的大小并使用 %llu 格式说明符打印无符号长整型值
    printf("打印 float 的字节数：%llu\n", sizeof(float));   // 使用 sizeof 运算符获取 float 类型的大小并使用 %llu 格式说明符打印无符号长整型值
    printf("打印 double 的字节数：%llu\n", sizeof(double)); // 使用 sizeof 运算符获取 double 类型的大小并使用 %llu 格式说明符打印无符号长整型值
}
【代码详解】

包含头文件 <stdio.h>，这是一个标准输入输出库文件，其中包含了 printf 函数的声明。

在 main 函数中，定义了整型变量 a 并初始化为 0，定义了浮点型变量 b 并初始化为 1.5，定义了双精度浮点型变量 c 并初始化为 5.78。

使用 printf 函数分别打印了变量 a 的值、int 类型的大小、float 类型的大小、double 类型的大小；分别使用 %d、%llu、%llu、%llu 格式说明符和相应的 sizeof 运算符获取变量的值和类型的大小。

【输出结果】

在大多数编译器中，sizeof(int) 表达式返回的结果是 int 类型在当前编译环境中的字节数。

通常情况下，int 类型在大部分平台上占据 4 个字节（32 位），但这并不是绝对的，它可能会在不同的平台和编译器上有所不同。

因此，当运行 sizeof(int) 时，输出结果为 4，说明在当前编译环境中 int 类型占据 4 个字节。

需要注意的是，sizeof 运算符返回的是无符号整型值，因此在使用 %llu 格式说明符打印 sizeof(int) 的结果时，需要使用无符号长整型 (unsigned long long) 格式来匹配参数的类型。
打印变量 a 的值：0
打印 int 的字节数：4
打印 float 的字节数：4
打印 double 的字节数：8

14. 变量：浮点数 float 的最小/大值

【示例代码】
#include<stdio.h>
#include <cfloat>

int main()
{
    int a = 0;                           // 定义并初始化整型变量 a
    float b = 1.5;                       // 定义并初始化浮点型变量 b
    double c = 5.78;                     // 定义并初始化双精度浮点型变量 c

    /* 参数传递 */
    printf("打印变量 a 的值：%d\n", a);  // 打印变量 a 的值，使用 %d 格式说明符打印整型值

    /* 字节数统计 */
    printf("打印 int 的字节数：%llu\n", sizeof(int));       // 使用 sizeof 运算符获取 int 类型的大小并使用 %llu 格式说明符打印无符号长整型值
    printf("打印 float 的字节数：%llu\n", sizeof(float));   // 使用 sizeof 运算符获取 float 类型的大小并使用 %llu 格式说明符打印无符号长整型值
    printf("打印 double 的字节数：%llu\n", sizeof(double)); // 使用 sizeof 运算符获取 double 类型的大小并使用 %llu 格式说明符打印无符号长整型值

    /* 浮点数 float 的最小/大值: %f 格式 */
    printf("打印浮点数 float 的最小值：%f\n", FLT_MIN);     // 打印浮点数 float 的最小值，使用 %f 格式说明符打印浮点数值
    printf("打印浮点数 float 的最大值：%f\n", FLT_MAX);     // 打印浮点数 float 的最大值，使用 %f 格式说明符打印浮点数值
    /* 浮点数 float 的最小/大值: %e 格式 */
    printf("打印浮点数 float 的最小值：%e\n", FLT_MIN);     // 打印浮点数 float 的最小值，使用 %e 格式说明符打印浮点数值
    printf("打印浮点数 float 的最大值：%e\n", FLT_MAX);     // 打印浮点数 float 的最大值，使用 %e 格式说明符打印浮点数值
}
【代码详解】

包含了头文件 <stdio.h> 和 <cfloat> 分别用于输入输出和浮点数相关常量。

在 main 函数中，定义了整型变量 a 并初始化为 0，定义了浮点型变量 b 并初始化为 1.5，定义了双精度浮点型变量 c 并初始化为 5.78。

使用 printf 函数打印了变量 a 的值，并使用 %d 格式说明符来打印整型值。

使用 printf 函数分别打印了 int 类型、float 类型和 double 类型的字节数，并使用 %llu 格式说明符和 sizeof 运算符来获取并打印无符号长整型值。

使用 printf 函数分别打印了浮点数 float 类型的最小值和最大值，并使用 %f 格式说明符来打印浮点数。

使用 printf 函数分别以科学计数法的格式打印了浮点数 float 类型的最小值和最大值，并使用 %e 格式说明符来打印浮点数。

【输出结果】

%f 是格式说明符，用于打印浮点数的值。

%e 是格式说明符，用于以科学计数法打印浮点数的值。

科学计数法：1.175494e-38 表示为 1.175494 乘以 10 的 -38 次方

科学计数法：3.402823e+38 表示为 3.402823 乘以 10 的 38 次方

打印变量 a 的值: 0：这是因为变量 a 被初始化为整型的默认值 0。

打印 int 的字节数: 4：int 类型通常占用 4 个字节（32 位）的内存空间。

打印 float 的字节数: 4：float 类型通常占用 4 个字节（32 位）的内存空间。

打印 double 的字节数: 8：double 类型通常占用 8 个字节（64 位）的内存空间。

打印浮点数 float 的最小值: 0.000000：FLT_MIN 是 float 类型的最小正非零值，通常为 0。

打印浮点数 float 的最大值: 340282346638528859811704183484516925440.000000：FLT_MAX 是 float 类型的最大值，通常是一个极大的数。

打印浮点数 float 的最小值: 1.175494e-38：这是使用科学计数法表示的 float 类型的最小正非零值。

打印浮点数 float 的最大值: 3.402823e+38：这是使用科学计数法表示的 float 类型的最大值。
打印变量 a 的值: 0
打印 int 的字节数: 4
打印 float 的字节数: 4
打印 double 的字节数: 8
打印浮点数 float 的最小值: 0.000000
打印浮点数 float 的最大值: 340282346638528859811704183484516925440.000000
打印浮点数 float 的最小值: 1.175494e-38
打印浮点数 float 的最大值: 3.402823e+38

【C++ 程序设计】实战：C++ 数据类型实践练习题（常量、变量）

一、常量

01. 常量的定义：符号常量

① 实型常量

② 整型常量

③ 字符常量

02. 常量的定义：有名常量

① 整型有名常量

② 单精度实型有名常量

③ 字符型有名常量

03. 字符常量：分数与排名

04. 有名常量：价格统计

05. 有名常量：平均分

二、变量

01. 变量的定义：有符号整型变量

① 有符号基本整型变量

② 有符号短整型变量

③ 有符号长整型变量

02. 变量的定义：无符号整型变量

① 无符号基本整型变量

② 无符号短整型变量

③ 无符号长整型变量

03. 变量的定义：实型变量

① 单精度实型变量

② 双精度实型变量

04. 变量的定义：字符型变量

① 字符型变量

05. 变量的初始化：有符号整型变量

① 有符号基本整型变量

② 有符号短整型变量

③ 有符号长整型变量

06. 变量的初始化：无符号整型变量

① 无符号基本整型变量

② 无符号短整型变量

③ 无符号长整型变量

07. 变量的初始化：实型变量

① 单精度实型变量

② 双精度实型变量

08. 变量的初始化：字符型变量

① 字符型变量

09. 变量：定义

10. 变量：初始化

11. 变量：参数传递

12. 变量：格式说明符

① 占位符 “%d” 改为格式说明符 “%llu”

② 占位符 “%d” 改为格式说明符 “%f” 或 “%e”

13. 变量：字节数统计

14. 变量：浮点数 float 的最小/大值

猜你喜欢