18.隐式转换

编程语言 > CPP > CPP入门 > CPP入门语法知识 编程语言 CPP CPP入门 CPP入门语法知识 类型转换
发布时间 :
字数:3.3k 阅读 : 评论:
  1. 18.类型转换-隐式转换
    1. 18.1 知识点
      1. 类型转换和隐式转换
      2. 赋值运算中的隐式转换
        1. 低精度隐式转换高精度
        2. 高精度隐式转换低精度
        3. string 类型与其他类型之间
        4. 无符号与有符号之间
      3. 数学计算中的隐式转换
        1. 混合计算规则
        2. 注意事项
      4. 总结
    2. 18.2 知识点代码
      1. Lesson18_类型转换_隐式转换.cpp
    3. 18.3 练习题
      1. 什么情况下会出现数据类型的隐式转换，请举例说明
        1. 赋值
        2. 算术运算
      2. 请将自己名字每一个字的首字母转换成数字并打印出来
    4. 18.4 练习题代码
      1. Lesson18_练习题.cpp

18.类型转换-隐式转换

18.1 知识点

类型转换和隐式转换

类型转换是指不同变量类型之间的相互转换。

隐式转换，也称为自动类型转换，由编译器自动执行，用于将一种数据类型的值转换为另一种数据类型。

赋值运算中的隐式转换

低精度隐式转换高精度

当右侧变量的精度比左侧低时，可以进行向上转换，通常不会有数据丢失或未定义行为：

int i; // 4byte
char c = 'A'; // 1byte
short s = 3; // 2byte
bool b = true; // 1byte

i = c;
cout << i << endl; // 输出: 65

i = s;
cout << i << endl; // 输出: 3

i = b;
cout << i << endl; // 输出: 1

高精度隐式转换低精度

当右侧变量的精度比左侧高时，可能会导致数据丢失或溢出，应尽量避免：

i = 60000;

c = i;
cout << c << endl; // 输出: `

s = i;
cout << s << endl; // 输出: -5563

b = i;
cout << b << endl; // 输出: 1

string 类型与其他类型之间

目前学习的类型中，string 类型与其他类型之间不存在隐式转换：

string str = "1";
str = i;
cout << str << endl; // 输出: `

无符号与有符号之间

无符号和有符号变量之间的隐式转换需谨慎处理：

i = -1;
unsigned u = i;
cout << u << endl; // 输出: 4294967295

u = 2200000000;
i = u;
cout << i << endl; // 输出: -2094967296

总结：

  • string 类型不能与其他类型进行隐式转换。
  • 低精度转换为高精度可放心使用。
  • 高精度转换为低精度需避免。
  • 无符号与有符号变量的混用需谨慎。

数学计算中的隐式转换

混合计算规则

在混合计算中，类型会被提升为范围更大的类型参与计算。例如：

int i = 10;
char c = 'a'; // ASCII: 97
short s = 11;
float f = 1.5f;
double d = 5.6;

cout << i + c + s + f + d << endl; // 输出: 125.1

注意事项

  1. 无符号与有符号数之间的混合计算
    如果有符号数为负数，转换为无符号类型可能出现问题。

  2. 结果装载的变量类型需为相对最大类型
    使用适当的变量类型避免丢失数据：

    i = i + c + s + f + d;
cout << i << endl; // 输出: 125（小数部分被舍弃）

  3. 浮点数装载整数计算结果时需注意丢弃小数的潜在问题
    默认非小数为整数，需显式声明浮点数参与计算以提高精度：

    d = 3 / 2;
cout << d << endl; // 输出: 1

d = 3 / 2.0;
cout << d << endl; // 输出: 1.5

总结

  1. 类型转换

    • 类型转换是指不同变量类型之间的相互转换。
    • 隐式转换由编译器自动执行。

  2. 赋值运算中的隐式转换

    • string 类型与其他类型不支持隐式转换。
    • 低精度转高精度安全可靠。
    • 高精度转低精度可能丢失数据，需谨慎。

  3. 数学计算中的隐式转换

    • 类型会被提升为范围更大的类型参与计算。
    • 避免无符号与有符号数之间的混合计算。
    • 结果装载变量需为相对最大类型。
    • 浮点数装载整数计算结果时注意精度问题。

18.2 知识点代码

Lesson18_类型转换_隐式转换.cpp

#include <iostream>
using namespace std;
int main()
{
    std::cout << "类型转换 隐式转换\n";

    #pragma region 知识点一 类型转换和隐式转换是什么

    // 类型转换 就是不同变量类型之间的相互转换

    // 隐式转换 也称为自动类型转换，由编译器自动执行的，
    //         用于将一种数据类型的值转换为另一种数据类型

    #pragma endregion

    #pragma region 知识点二 赋值运算中的隐式转换

    cout << "赋值运算中的隐式转换" << endl;
    //当在使用 赋值运算符 = 时
    // A = B
    // 当A和B的类型不匹配时
    // C++会尝试将右侧的值转换为左侧变量的类型


    cout << "低精度隐式转换高精度" << endl;
    //1.低精度隐式转换高精度（B的精度比A低）：
    //  通常不会有任何问题，这种转换可以被称为 向上转换
    //  不会丢失数据，也不会出现未定义行为
    int i;//4byte
    //ASCII码 
    char c = 'A';//1byte
    short s = 3;//2byte
    bool b = true;//1byte
    i = c;
    cout << i << endl;//65
    i = s;
    cout << i << endl;//3
    i = b;
    cout << i << endl;//1


    cout << "高精度隐式转换低精度" << endl;
    //2.高精度隐式转换低精度(B的精度比A高)：
    //  会导致数据丢失或溢出，若要追求准确性时，要尽量避免这样使用
    i = 60000;
    c = i;
    cout << c << endl;//`
    s = i;
    cout << s << endl;//-5563
    b = i;
    cout << b << endl;//1


    cout << "string类型与其他类型之间不存在隐式转换" << endl;
    //3.目前学习的类型中，string类型与其他类型之间不存在隐式转换
    string str = "1";
    //字符串 去存储一个数值 会把这个数值 当成一个char去转换（并不会得到对应的数值）
    //不会用str和其他类型去进行隐式转换
    str = i;
    cout << str << endl;//`


    cout << "无符号和有符号之间的隐式转换" << endl;
    //4.无符号和有符号之间的隐式转换
    //  同样遵循上面的规则
    //  但是如果想要把一个负数用无符号类型装载
    //  得到的结果是不准确的，不要这样使用
    //  而有符号装载无符号变量时可能会溢出
    i = -1;
    //如果无法确定有符号数 肯定是正数 那就不要用无符号容器去装载有符号
    unsigned u = i;
    cout << u << endl;//4294967295
    u = 2200000000;
    i = u;
    cout << i << endl;//-2094967296


    //总结：
    // 在进行赋值运算时，C++会自动进行隐式转换
    // 目前我们学习的变量类型中string类型不能和其他的类型进行隐式转换
    // 低精度转高精度，我们一般可以放心使用
    // 高精度转低精度，我们如果没有特殊需求那么要尽量避免使用
    // 在没有准确把握时不要用无符号和有符号变量进行相互赋值装载

    #pragma endregion

    #pragma region 知识点三 数学计算中的隐式转换

    cout << "数学计算中的隐式转换" << endl;

    //当我们利用各种不同数值类型的变量进行混合计算时
    //编译器会按照一定的规则将他们转换为同一类型进行计算
    //主要遵循的规则是：
    //类型会被提升为范围更大的类型参与计算
    //比如:
    // int 和 double一起计算，int会被转换为double进行计算
    i = 10;
    char c2 = 'a';//97
    short s2 = 11;
    float f = 1.5f;
    double d2 = 5.6;
    cout << i + c2 + s2 + f + d2 << endl;//10 + 97 + 11 + 1.5 + 5.6 = 125.1


    //关键点注意
    //1.在没有把握时，不要将无符号和有符号数之间进行混合计算
    //  原因：如果有符号是负数 那么如果转换为无符号 这个时候负数会出现问题 就会得到意想不到的结果

    //2.要保证用来装载计算结果的变量类型是“相对最大”类型
    i = i + c2 + s2 + f + d2;
    cout << i << endl;//125 舍弃小数0.1 因为了使用int

    //3.用浮点数装载整数类型的计算结果时，要注意整数计算丢弃小数的潜在问题
    //默认书写的非小数为整数
    //会当成整数计算
    // 我们必须明确后面有数值是浮点数（相当于提高计算时的精度 其他类型的 会隐式转换为高精度进行计算）
    d2 = 3 / 2;
    cout << d2 << endl;//1
    d2 = 3 / 2.0;
    cout << d2 << endl;//1.5

    #pragma endregion

    #pragma region 总结

    // 类型转换 就是不同变量类型之间的相互转换

    // 隐式转换 也称为自动类型转换，由编译器自动执行的，
    //         用于将一种数据类型的值转换为另一种数据类型

    // 在进行赋值运算时，C++会自动进行隐式转换
    // 目前我们学习的变量类型中string类型不能和其他的类型进行隐式转换
    // 低精度转高精度，我们一般可以放心使用
    // 高精度转低精度，我们如果没有特殊需求那么要尽量避免使用
    // 在没有准确把握时不要用无符号和有符号变量进行相互赋值装载

    // 在进行数学计算时
    // 类型会被提升为范围更大的类型参与计算
    // 1.在没有把握时，不要将无符号和有符号数之间进行混合计算
    // 2.要保证用来装载计算结果的变量类型是“相对最大”类型
    // 3.用浮点数装载整数类型的计算结果时，要注意整数计算丢弃小数的潜在问题

    #pragma endregion
}

18.3 练习题

什么情况下会出现数据类型的隐式转换，请举例说明

赋值

  • 当 A = B 且 A 和 B 的变量类型不同，就会发生隐式转换。
  • 如果 B 的类型精度较低（存储范围较小），转换为 A 的类型（精度较高）通常不会有问题。
  • 如果 B 的类型精度较高（存储范围较大），转换为 A 的类型（精度较低）可能会导致数据丢失或意外结果：
    1. 无符号变量装载有符号变量（如负数），可能得不到准确结果。
    2. 整型装载浮点数时，小数点后面的部分会丢失。

算术运算

  • 参与计算的变量或数值会隐式转换为其中最高精度的类型进行计算。
  • 注意事项：
    1. 无符号和有符号的混合运算可能导致错误结果。
    2. 结果需要装载到容器中时，应该选择精度较高的容器。
    3. 如果需要保留小数，应确保参与计算的变量中至少有一个是浮点类型。
float f = 3 / 2.0f;  // 隐式转换为浮点数，结果为 1.5

请将自己名字每一个字的首字母转换成数字并打印出来

char l = 'L';
char w = 'W';
char t = 'T';

// 隐式转换：char 转为 int，ASCII 码值存储在整型变量中
int num1 = l;
cout << num1 << endl;  // 输出 76

int num2 = w;
cout << num2 << endl;  // 输出 87

int num3 = t;
cout << num3 << endl;  // 输出 84

// 小写字母示例
l = 'l';
w = 'w';
t = 't';

num1 = l;
cout << num1 << endl;  // 输出 108

num2 = w;
cout << num2 << endl;  // 输出 119

num3 = t;
cout << num3 << endl;  // 输出 116

18.4 练习题代码

Lesson18_练习题.cpp

#include <iostream>
using namespace std;
int main()
{
    std::cout << "隐式转换 练习题\n";

    #pragma region 练习题一

    //什么情况下会出现数据类型的隐式转换，请举例说明

    //1.赋值
    //  A = B
    //  A、B变量类型不同 就存在隐式转换  B会自动的转换为A的类型
    //  如果是精度较高（存储范围更大的）的 转载精度较低（存储范围更小的）的 那么不会有什么问题
    //  需要注意的是，精度较低的转载精度较高的，会出现数据的损失，甚至得到一个我们意想不到的结果
    //  1.无符号的容器去装载一个有符号的变量（负数），这个时候并不能得到准确的结果
    //  2.用整型装载一个浮点数，小数点后面的数会丢失

    //2.算数运算时
    //  所有参与计算的变量或数值 会自动的隐式转换为其中最高的精度进行计算
    //  需要注意：
    //  1.无符号和有符号的问题
    //  2.我们如果要用容器去装载结果，那么一定要选择精度较高的容器
    //  3.如果想要保留小数，那么一定要确定后方是否有浮点数类型的变量
    float f = 3 / 2.0f;

    #pragma endregion

    #pragma region 练习题二

    //请将自己名字每一个字的首字母转换成数字并打印出来

    char l = 'L';
    char w = 'W';
    char t = 'T';
    // 隐式转换 char转为int，ASCII码会将字符的ASCII码值存储在整型变量中
    int num1 = l;
    cout << num1 << endl;  // 76
    int num2 = w;
    cout << num2 << endl;  // 87
    int num3 = t;
    cout << num3 << endl;  // 84

    l = 'l';
    w = 'w';
    t = 't';
    // 隐式转换 char转为int，ASCII码会将字符的ASCII码值存储在整型变量中
    num1 = l;
    cout << num1 << endl;  // 108
    num2 = w;
    cout << num2 << endl;  // 119
    num3 = t;
    cout << num3 << endl;  // 116

    #pragma endregion

}
转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 785293209@qq.com

赏

©2016-2024 Tao

Built with Hexo and 3-hexo theme

×

喜欢就点赞,疼爱就打赏