C++输出为非科学计数法不同数据类型表示范围

一、C++数据类型

1、基本的内置类型

2、修饰符

（1）signed 和 unsigned

（2）short 和 long

（3）区别总结

默认情况

二、类型转换

1、静态转换（Static Cast）

2、动态转换（Dynamic Cast）

3、常量转换（Const Cast）

4、重新解释转换（Reinterpret Cast）

（1）语法

三、输出为非科学计数法

1、修改为非科学计数法

一、C++数据类型

编程语言在进行编程时，需要用到各种变量来存储信息。变量保留的是它所存储的内存位置，即在创建一个变量的时候，就会在内存中保留一些空间。

1、基本的内置类型

类型	关键字
布尔型	bool
字符型	char
整型	int
浮点型	float
双浮点型	double
无类型	void
宽字符型	wchar_t

2、修饰符

一些基本类型可以使用一个或者多个类型修饰符进行修饰：

signed
unsigned
short
long

这些修饰符可以影响变量能够表示的范围和所占用的内存空间。

（1）signed 和 unsigned

signed：表示带符号的类型。例如，int 默认是 signed int，即可以表示正数、负数和零。
unsigned：表示无符号的类型，只能表示非负数（包括零）。例如，unsigned int 只能表示非负整数。

（2）short 和 long

short：缩短整数的存储空间。例如，short int 或简写为 short，通常比普通的 int 类型使用更少的存储空间，但能表示的范围也相应较小。
long：增加整数的存储空间。例如，long int 或简写为 long，通常比普通的 int 类型使用更多的存储空间，能够表示更大范围的整数值。

（3）区别总结

signed 和 unsigned 的区别在于能够表示的数值范围：signed 可以表示正数、负数和零，而 unsigned 只能表示非负数。
short 和 long 的区别在于占用的存储空间和能够表示的数值范围：short 使用较少的存储空间但表示的范围较小，long 使用较多的存储空间但能表示更大的数值范围。

默认情况

① 不同系统会有所差异，一字节为 8 位。

② 默认情况下，int、short、long都是带符号的，即 signed。

③ long int 8 个字节，int 都是 4 个字节。

3、数据类型表示范围

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

二、类型转换

类型转换是将一个数据类型的值转为另一种数据类型的值。

C++ 中有四种类型转换：静态转换、动态转换、常量转换和重新解释转换。

1、静态转换（Static Cast）

静态转换是将一种数据类型的值强制转换为另一种数据类型的值。
静态转换通常用于比较类型相似的对象之间的转换，例如将 int 类型转换为 float 类型。
静态转换不进行任何运行时类型检查，因此可能会导致运行时错误。

举个例子：

#include <iostream>
#include <typeinfo>
using namespace std;
int main(){
    int a = 10;
    float b = static_cast<float>(a);

    cout << "type(a): " << typeid(a).name() << endl;
    cout << "type(b): " << typeid(b).name() << endl;
    return 0;
}

2、动态转换（Dynamic Cast）

动态转换通常用于将一个基类指针或引用转换为派生类指针或引用。

动态转换在运行时进行类型检查，如果不能进行转换则返回空指针或引发异常。

举个例子：

#include <iostream>

// 基类
class Base {
public:
    virtual ~Base() {} // 虚析构函数确保多态性
};

// 派生类
class Derived : public Base {  // 派生类
};

int main() {
    // 创建派生类对象的基类指针
    Base* ptr_base = new Derived();

    // 尝试将基类指针转换为派生类指针
    Derived* ptr_derived = dynamic_cast<Derived*>(ptr_base);

    // 检查转换是否成功
    if (ptr_derived != nullptr) {
        std::cout << "dynamic_cast success: " << static_cast<void*>(ptr_derived) << std::endl;
        // 安全地使用ptr_derived
    } else {
        std::cout << "dynamic_cast false." << std::endl;
    }

    // 释放内存
    delete ptr_base;

    return 0;
}

3、常量转换（Const Cast）

const属性：const关键字用于声明变量，表示该变量或对象在声明后不能被修改。如果有一个const对象或者指针，不能直接通过它来修改其值或者通过它调用非const成员函数。

所以常量转换的目的是为了去除对象或指针的const属性，使得可以修改原本被声明为const的对象或者调用非const成员函数。

常量转换用于将 const 类型的对象转换为非 const 类型的对象。

常量转换只能用于转换掉 const 属性，不能改变对象的类型。（例如，如果一个对象的类型是 const T，常量转换后得到的仍然是 T 类型，只是它现在不再是 const T，可以进行修改）

举个例子：

#include <iostream>

void modifyValue(int* ptr) {
    *ptr = 20; // 修改指针所指向的值
}

int main() {
    const int x = 10; // 声明一个 const int 类型的变量 x
    
    // 使用常量转换去除 const 属性
    int* ptr = const_cast<int*>(&x);
    
    // 现在可以通过 ptr 修改原本的 const 变量 x
    modifyValue(ptr);
    std::cout << "Modified value of x: " << x << std::endl; // 输出修改后的值
    return 0;
}

在这个示例中，通过使用 const_cast 去除了 x 的 const 属性，使得可以通过指针 ptr 修改 x 的值。

但需要注意的是，尽管这种操作是合法的，也应该谨慎使用，因为 const 的作用通常是为了确保代码的安全性和可维护性。

4、重新解释转换（Reinterpret Cast）

用于将一个数据类型的值重新解释为另一个数据类型的值，而不进行任何类型检查（如果进行错误的转换，可能会导致未定义的行为或者程序崩溃）。

这种转换通常用于需要在不同类型之间转换的情况，尤其是在低级别的系统编程或者处理特定硬件的时候可能会用到。

（1）语法

在 C++ 中，重新解释转换使用 reinterpret_cast 运算符来执行。其语法如下：

reinterpret_cast<new_type>(expression)

new_type 是要转换的目标类型。
expression 是要转换的表达式，可以是一个指针、引用、整数或者其他表达式。

举个例子：

#include <iostream>

int main() {
    int num = 10;
    float* float_ptr = reinterpret_cast<float*>(&num);
    
    // 输出重新解释后的浮点数值
    std::cout << "num value: " << num << std::endl;
    std::cout << "Reinterpreted float value: " << *float_ptr << std::endl;
    
    return 0;
}

使用了 reinterpret_cast 将一个 int 类型的变量 num 的地址转换为一个 float* 类型的指针 float_ptr，然后尝试输出这个指针所指向的浮点数值。

使用 reinterpret_cast<float*>(&num) 将 int 类型的地址转换为 float* 类型的指针时，实际上是将 num 的二进制表示在浮点数格式下进行了解释。

根据输出结果 "1.4013e-44"，这意味着在系统或者编译器中，将 int 类型的变量 num 的地址解释为 float* 类型指针所得到的浮点数值非常接近于 1.4013 乘以 10 的负 44 次方。
这个值非常接近于浮点数表示的最小正规范化值（normalized value），通常表示非常接近于 0 的数值。

三、输出为非科学计数法

在正常使用基本内嵌类型的时候，打印出来的数值就是科学计数法。

#include <iostream>

int main() {
    int num = 558558571;
    float num_float = num * 0.33;
    double num_double = num * 0.33;
    
    std::cout << "num value: " << num << std::endl;
    std::cout << "num_float value: " << num_float << std::endl;
    std::cout << "num_double value: " << num_double << std::endl;
    return 0;
}

1、修改为非科学计数法

#include <iostream>
#include <iomanip>

int main() {
    int num = 558558571;
    float num_float = static_cast<float>(num) * 0.33;
    double num_double = static_cast<double>(num) * 0.33;
    
    std::cout << "num value: " << num << std::endl;
    std::cout << std::fixed << std::setprecision(2);
    std::cout << "num_float value: " << num_float << std::endl;
    std::cout << "num_double value: " << num_double << std::endl;
    return 0;
}

其中

设置 std::cout 的输出格式，具体包含两个操作：

std::fixed：
- std::fixed 是 iomanip 头文件中的一个标志，用于设置浮点数的输出格式为固定小数点表示法。这意味着浮点数将以小数点形式输出，而不是科学计数法。
- 例如，一个浮点数 12.3456 在使用 std::fixed 后输出为 12.35，即小数点后保留固定位数的数字。
std::setprecision(2)：
- std::setprecision(2) 是 iomanip 头文件中的一个函数，用于设置浮点数输出的精度，即小数点后的位数。
- 在这里，2 表示将浮点数的小数部分保留两位有效数字。例如，如果一个浮点数是 12.3456，设置精度为 2 后输出为 12.35。