「C++系列」C++ 数据类型

文章目录

  • 一、C++ 数据类型
  • 二、C++ 数据类型占位与范围
  • 三、类型转换
    • 1. 隐式类型转换(Automatic Type Conversion)
    • 2. 显式类型转换(Explicit Type Conversion)
    • 3. 示例代码
    • 四、数据类型案例
      • 1. 整型
      • 2. 浮点型
      • 3. 字符型
      • 4. 布尔型
      • 5. 枚举类型
      • 6. 指针类型
      • 7. 引用类型
      • 五、相关链接

        一、C++ 数据类型

        C++ 数据类型定义了存储在变量中的数据的种类,不同的数据类型决定了数据在内存中的存储方式,以及它们可以执行的操作。以下是C++中的基本数据类型:

        1. 整型(Integer Types):
        • int:有符号整数类型,根据编译器和系统架构的不同,其大小通常为16位、32位或64位。
        • short:有符号短整型,通常比int小。
        • long:有符号长整型,通常比int大。
        • long long:有符号长长整型,比long更大。
        • 无符号整型:每种整型都有对应的无符号版本(例如unsigned int、unsigned short、unsigned long、unsigned long long),它们只能存储非负整数。
          1. 浮点型(Floating-Point Types):
          • float:单精度浮点型,用于存储带小数点的数,通常占用4个字节。
          • double:双精度浮点型,比float具有更高的精度和更大的范围,通常占用8个字节。
          • long double:长双精度浮点型,比double具有更高的精度。
            1. 字符型(Character Types):
            • char:字符型,用于存储单个字符(如字母、数字、标点符号等)。实际上,char是整型的一种特殊形式,可以参与整数运算。字符类型有char、signed char、unsigned char之分,具体有无符号由编译器决定。
              1. 布尔型(Boolean Type):
              • bool:布尔型只有两个值:true和false,常用于条件判断和逻辑运算。在C++中,布尔类型会被自动转换为整型,其中true对应的整数值为1,false对应的整数值为0。
                1. 宽字符型(Wide Character Type):
                • wchar_t:用于存储宽字符(如Unicode字符)。
                  1. 枚举类型(Enumeration Types):
                  • 枚举类型是一种用户定义的数据类型,允许为整数常量指定一个名称,使代码更易于阅读和维护。例如:enum Color { RED, GREEN, BLUE };
                    1. 指针类型(Pointer Types):
                    • 指针类型是一种特殊的数据类型,用于存储内存地址。指针变量可以指向任何类型的内存地址,包括变量、数组、函数等。
                      1. 引用类型(Reference Types):
                      • 引用是C++中的另一种特殊数据类型,允许为变量创建一个别名。引用在声明时必须初始化,并且一旦初始化,就不能再指向其他变量。

                        二、C++ 数据类型占位与范围

                        类型范围
                        char1 个字节-128 到 127 或者 0 到 255
                        unsigned char1 个字节0 到 255
                        signed char1 个字节-128 到 127
                        int4 个字节-2147483648 到 2147483647
                        unsigned int4 个字节0 到 4294967295
                        signed int4 个字节-2147483648 到 2147483647
                        short int2 个字节-32768 到 32767
                        unsigned short int2 个字节0 到 65,535
                        signed short int2 个字节-32768 到 32767
                        long int8 个字节-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
                        signed long int8 个字节-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
                        unsigned long int8 个字节0 到 18,446,744,073,709,551,615
                        float4 个字节精度型占4个字节(32位)内存空间,+/- 3.4e +/- 38 (~7 个数字)
                        double8 个字节双精度型占8 个字节(64位)内存空间,+/- 1.7e +/- 308 (~15 个数字)
                        long long8 个字节双精度型占8 个字节(64位)内存空间,表示 -9,223,372,036,854,775,807 到 9,223,372,036,854,775,807 的范围
                        long double16 个字节长双精度型 16 个字节(128位)内存空间,可提供18-19位有效数字。
                        wchar_t2 或 4 个字节1 个宽字符

                        三、类型转换

                        在C++中,类型转换(也称为类型强制或类型转换)是将一个数据类型的值转换为另一个数据类型的值的过程。C++支持几种类型的类型转换,包括隐式类型转换(也称为自动类型转换)和显式类型转换(也称为强制类型转换)。

                        1. 隐式类型转换(Automatic Type Conversion)

                        隐式类型转换是编译器自动执行的,而无需程序员明确指定。这种转换通常发生在以下情况:

                        • 当一个较小的数据类型(如int)被赋值给一个较大的数据类型(如long)时。
                        • 当一个整数被赋值给一个浮点类型(如float或double)时。
                        • 当表达式中涉及到混合类型的操作数时(例如,int和double相加)。

                          2. 显式类型转换(Explicit Type Conversion)

                          显式类型转换需要程序员明确指定。在C++中,有几种显式类型转换的方法:

                          1. C风格的类型转换:

                            使用()来指定要转换的目标类型。例如:

                          int x = 10;
                          double y = (double)x; // 将int转换为double
                          
                          1. C++风格的类型转换:

                            C++提供了四种新的类型转换运算符,它们提供了更好的类型安全和可读性。

                          • static_cast:用于基本数据类型之间的转换,以及类的向上/向下转型(无危险情况)。
                          • dynamic_cast:主要用于类的向上/向下转型,特别是在继承层次结构中。只适用于指向对象的指针或引用。
                          • const_cast:用于删除或添加常量性。
                          • reinterpret_cast:进行底层的重新解释转换,如指针类型之间的转换。这种转换高度不安全,应谨慎使用。

                            示例:

                            int x = 10;
                            double y = static_cast(x); // 使用static_cast进行转换
                            

                            3. 示例代码

                            下面是一个包含各种类型转换的示例代码:

                            #include class Base {};
                            class Derived : public Base {};
                            int main() { int a = 10;
                                double b = static_cast(a); // 显式类型转换(基本类型)
                                Derived* d = new Derived();
                                Base* b_ptr = d; // 隐式类型转换(向上转型)
                                // Derived* d2 = static_cast(b_ptr); // 显式向上转型是安全的,但这里没有实际必要
                                Derived* d2 = dynamic_cast(b_ptr); // 显式向下转型(需要dynamic_cast)
                                const int c = 20;
                                int* non_const_ptr = const_cast(&c); // 移除const属性(危险)
                                int* int_ptr = reinterpret_cast(0x1234); // 底层重新解释转换(高度危险)
                                std::cout << "a as double: " << b << std::endl;
                                std::cout << "d2 points to a Derived object: " << (d2 == d ? "true" : "false") << std::endl;
                                // 注意:不要解引用non_const_ptr或依赖int_ptr,因为它们是不安全的
                                delete d; // 不要忘记释放内存
                                return 0;
                            }
                            

                            dynamic_cast在运行时检查转换是否有效,如果转换无效(例如,将指向基类对象的指针向下转型为派生类,而该基类对象实际上并不是派生类的实例),则dynamic_cast会返回空指针(对于指针)或抛出异常(对于引用)。这是dynamic_cast相比static_cast更安全的一个方面。

                            四、数据类型案例

                            一些C++数据类型的详细案例代码,涵盖了整型、浮点型、字符型、布尔型、枚举类型、指针类型、引用类型以及用户自定义类型(如结构体和类)。

                            1. 整型

                            #include int main() { int intVar = 10;
                                short shortVar = 20;
                                long longVar = 3000000000;
                                unsigned int unsignedIntVar = 4294967295U; // 最大的无符号int值(取决于系统)
                                std::cout << "intVar: " << intVar << std::endl;
                                std::cout << "shortVar: " << shortVar << std::endl;
                                std::cout << "longVar: " << longVar << std::endl;
                                std::cout << "unsignedIntVar: " << unsignedIntVar << std::endl;
                                return 0;
                            }
                            

                            2. 浮点型

                            #include int main() { float floatVar = 3.14f;
                                double doubleVar = 3.141592653589793238;
                                std::cout << "floatVar: " << floatVar << std::endl;
                                std::cout << "doubleVar: " << doubleVar << std::endl;
                                return 0;
                            }
                            

                            3. 字符型

                            #include int main() { char charVar = 'A';
                                char anotherCharVar = 65; // ASCII码值,等同于'A'
                                std::cout << "charVar: " << charVar << std::endl;
                                std::cout << "anotherCharVar: " << anotherCharVar << std::endl;
                                return 0;
                            }
                            

                            4. 布尔型

                            #include int main() { bool boolVar = true;
                                if (boolVar) { std::cout << "boolVar is true" << std::endl;
                                } else { std::cout << "boolVar is false" << std::endl;
                                }
                                boolVar = false;
                                std::cout << "boolVar is now " << (boolVar ? "true" : "false") << std::endl;
                                return 0;
                            }
                            

                            5. 枚举类型

                            #include enum Color { RED, GREEN, BLUE };
                            int main() { Color myColor = RED;
                                switch (myColor) { case RED:
                                        std::cout << "The color is red." << std::endl;
                                        break;
                                    case GREEN:
                                        std::cout << "The color is green." << std::endl;
                                        break;
                                    case BLUE:
                                        std::cout << "The color is blue." << std::endl;
                                        break;
                                    default:
                                        std::cout << "Unknown color." << std::endl;
                                }
                                return 0;
                            }
                            

                            6. 指针类型

                            #include int main() { int num = 10;
                                int* ptr = # // ptr指向num的内存地址
                                std::cout << "Value of num: " << num << std::endl;
                                std::cout << "Address of num: " << &num << std::endl;
                                std::cout << "Value of ptr (num's address): " << ptr << std::endl;
                                std::cout << "Value pointed by ptr (num's value): " << *ptr << std::endl;
                                return 0;
                            }
                            

                            7. 引用类型

                            #include int main() { int num = 10;
                                int& ref = num; // ref是num的引用
                                std::cout << "Value of num: " << num << std::endl;
                                std::cout << "Value of ref (same as num): " << ref << std::endl;
                                ref = 20; // 修改ref也会修改num
                                std::cout << "After modification, value of num: " << num << std::endl;
                                return 0;
                            }
                            

                            五、相关链接

                            1. Visual Studio Code下载地址
                            2. Sublime Text下载地址
                            3. 「C++系列」C++简介、应用领域
                            4. 「C++系列」C++ 基本语法