精华内容
下载资源
问答
  • 浮点型:float(浮点型)、double(双精度浮点型);字符型:char(字符型);布尔型:boolean(布尔型)。二、整型中 byte、short、int、long 取值范围byte:一个字节有8位,去掉符号位还有7位,正数避免进位还要减1,...

    一、8种基本数据类型(4整,2浮,1符,1布):

    整型:byte(最小的数据类型)、short(短整型)、int(整型)、long(长整型);

    浮点型:float(浮点型)、double(双精度浮点型);

    字符型:char(字符型);

    布尔型:boolean(布尔型)。

    二、整型中 byte、short、int、long 取值范围

    byte:一个字节有8位,去掉符号位还有7位,正数为避免进位还要减1,因此byte的取值范围为:-2^7 ~ (2^7-1),也就是 -128~127 之间。

    short:short用16位存储,去掉符号位还有15位,正数为避免进位还要减1,因此short的取值范围是:-2^15 ~ (2^15-1)。

    int:整型用32位存储,去掉符号位还有31位,正数为避免进位还要减1,因此整型的取值范围是 -2^31 ~ (2^31-1)。

    long:长整型用64位存储,去掉符号位还有63位,正数为避免进位还要减1,因此长整型的取值范围是 -2^63 ~ (2^63-1)。

    三:浮点型数据

    浮点类型是指用于表示小数的数据类型。

    单精度和双精度的区别:

    单精度浮点型float,用32位存储,1位为符号位, 指数8位, 尾数23位,即:float的精度是23位,能精确表达23位的数,超过就被截取。

    双精度浮点型double,用64位存储,1位符号位,11位指数,52位尾数,即:double的精度是52位,能精确表达52位的数,超过就被截取。

    双精度类型double比单精度类型float具有更高的精度,和更大的表示范围,常常用于科学计算等高精度场合。

    浮点数与小数的区别:

    1)在赋值或者存储中浮点类型的精度有限,float是23位,double是52位。

    2)在计算机实际处理和运算过程中,浮点数本质上是以二进制形式存在的。

    3)二进制所能表示的两个相邻的浮点值之间存在一定的间隙,浮点值越大,这个间隙也会越大。如果此时对较大的浮点数进行操作时,浮点数的精度问题就会产生,甚至出现一些“不正常"的现象。

    为什么不能用浮点数来表示金额

    先给出结论:金额用BigDecimal !!!

    1)精度丢失问题

    从上面我们可以知道,float的精度是23位,double精度是63位。在存储或运算过程中,当超出精度时,超出部分会被截掉,由此就会造成误差。

    对于金额而言,舍去不能表示的部分,损失也就产生了。

    f0e091509ed1f34577f341b7d5fa8c8c.png

    32位的浮点数由3部分组成:1比特的符号位,8比特的阶码(exponent,指数),23比特的尾数(Mantissa,尾数)。这个结构会表示成一个小数点左边为1,以底数为2的科学计数法表示的二进制小数。浮点数的能表示的数据大小范围由阶码决定,但是能够表示的精度完全取决于尾数的长度。long的最大值是2的64次方减1,需要63个二进制位表示,即便是double,52位的尾数也无法完整的表示long的最大值。不能表示的部分也就只能被舍去了。对于金额,舍去不能表示的部分,损失也就产生了。

    了解了浮点数表示机制后,丢失精度的现象也就不难理解了。但是,这只是浮点数不能表示金额的原因之一。还有一个深刻的原因与进制转换有关。十进制的0.1在二进制下将是一个无线循环小数。

    eg:

    public classMyTest {public static voidmain(String[] args) {float increment = 0.1f;float expected = 1;float sum = 0;for (int i = 0; i < 10; i++) {

    sum+=increment;

    System.out.println(sum);

    }if (expected ==sum) {

    System.out.println("equal");

    }else{

    System.out.println("not equal ");

    }

    }

    }

    输出结果:

    0.1

    0.2

    0.3

    0.4

    0.5

    0.6

    0.70000005

    0.8000001

    0.9000001

    1.0000001not equal

    2)进制转换误差

    从上面我们可以知道,在计算机实际处理和运算过程中,浮点数本质上是以二进制形式存在的。

    而十进制的0.1在二进制下将是一个无限循环小数,这就会导致误差的出现。

    如果一个小数不是2的负整数次幂,用浮点数表示必然产生浮点误差。

    换言之:A进制下的有限小数,转换到B进制下极有可能是无限小数,误差也由此产生。

    金额计算不能用doube!!!!金额计算不能用doube!!!!金额计算不能用doube!!!!金额计算必须用BigDecimal

    浮点数不精确的根本原因在于:尾数部分的位数是固定的,一旦需要表示的数字的精度高于浮点数的精度,那么必然产生误差!

    解决这个问题的方法是BigDecimal的类,这个类可以表示任意精度的数字,其原理是:用字符串存储数字,转换为数组来模拟大数,实现两个数组的数学运算并将结果返回。

    BigDecimal的使用要点:

    1、BigDecimal变量初始化——必须用传入String的构造方法

    BigDecimal num1 = new BigDecimal(0.005);//用数值转换成大数,有误差

    BigDecimal num12 = new BigDecimal("0.005");//用字符串转换成大数,无误差

    因为:不是所有的浮点数都能够被精确的表示成一个double 类型值,有些浮点数值不能够被精确的表示成 double 类型值时,它会被表示成与它最接近的 double 类型的值,此时用它来初始化一个大数,会“先造成了误差,再用产生了误差的值生成大数”,也就是“将错就错”。

    2、使用除法函数在divide的时候要设置各种参数,要精确的小数位数和舍入模式,其中有8种舍入模式:

    1、ROUND_UP

    远离零的舍入模式。

    在丢弃非零部分之前始终增加数字(始终对非零舍弃部分前面的数字加1)。

    注意,此舍入模式始终不会减少计算值的大小。2、ROUND_DOWN

    接近零的舍入模式。

    在丢弃某部分之前始终不增加数字(从不对舍弃部分前面的数字加1,即截短)。

    注意,此舍入模式始终不会增加计算值的大小。3、ROUND_CEILING

    接近正无穷大的舍入模式。

    如果 BigDecimal 为正,则舍入行为与 ROUND_UP 相同;

    如果为负,则舍入行为与 ROUND_DOWN 相同。

    注意,此舍入模式始终不会减少计算值。4、ROUND_FLOOR

    接近负无穷大的舍入模式。

    如果 BigDecimal 为正,则舍入行为与 ROUND_DOWN 相同;

    如果为负,则舍入行为与 ROUND_UP 相同。

    注意,此舍入模式始终不会增加计算值。5、ROUND_HALF_UP

    向“最接近的”数字舍入,如果与两个相邻数字的距离相等,则为向上舍入的舍入模式。

    如果舍弃部分>= 0.5,则舍入行为与 ROUND_UP 相同;否则舍入行为与 ROUND_DOWN 相同。

    注意,这是我们大多数人在小学时就学过的舍入模式(四舍五入)。6、ROUND_HALF_DOWN

    向“最接近的”数字舍入,如果与两个相邻数字的距离相等,则为上舍入的舍入模式。

    如果舍弃部分> 0.5,则舍入行为与 ROUND_UP 相同;否则舍入行为与 ROUND_DOWN 相同(五舍六入)。7、ROUND_HALF_EVEN

    向“最接近的”数字舍入,如果与两个相邻数字的距离相等,则向相邻的偶数舍入。

    如果舍弃部分左边的数字为奇数,则舍入行为与 ROUND_HALF_UP 相同;

    如果为偶数,则舍入行为与 ROUND_HALF_DOWN 相同。

    注意,在重复进行一系列计算时,此舍入模式可以将累加错误减到最小。

    此舍入模式也称为“银行家舍入法”,主要在美国使用。

    如果前一位为奇数,则入位,否则舍去。

    以下例子为保留小数点1位,那么这种舍入方式下的结果。1.15>1.2 1.25>1.2

    8、ROUND_UNNECESSARY

    断言请求的操作具有精确的结果,因此不需要舍入。

    如果对获得精确结果的操作指定此舍入模式,则抛出ArithmeticException。

    展开全文
  • 浮点型还包括长双精度型 1、整型数据 包括整型变量和整型常量 1)整型变量: -基本类型int型,在整型的表示符号int前加上不同的修饰,就可以将int型扩展成别的类型,如short int -用有符号(signed)和无符号...

    基本数据类型

    在这里插入图片描述

    另外,整形还包括了长长整形
    浮点型还包括长双精度型

    一、整型数据

    包括整型变量和整型常量
    1、整型变量:
    1)基本类型为int型,在整型的表示符号int前加上不同的修饰符,就可以将int型扩展成别的类型,如short int
    2)用有符号(signed)和无符号(unsigned)A两个修饰符来表示正负,如果没有添加修饰符则默认为有符号型(signed)
    3)有符号型(signed int a)可以简写为int a
    无符号型(unsigned int b)可以简写为unsigned b
    4)计算机中的数据用二进制表示,每一位(bit)就表示一个0或者1,而每8个位又组成一个字节,字节是计算机存储的单位
    5)取值范围;
    -类型----------存储大小-----------值范围
    char-----------1 字节------------(-128 即-(2^7) 到 127 (2^7-1))
    unsigned**char—1字节------0到255 (2^8 - 1)
    signed char--------1 字节-----128 即-(2^7) 到 127 (2^7-1)
    short-----------------2 字节 ----32,768 (- 2^15) 到 32,767 (2^15 -1)
    signed short-------2 字节-----32,768 (- 2^15) 到 32,767 (2^15 -1)
    unsigned short —2 字节 ----0 到 65,535 (2^16 - 1)
    int/signed int-------4 字节-----( -2,147,483,648 (- 2^31) 到 2,147,483,647 (2^31 -1))
    unsigned int ----- 4 字节------- 0 到 4,294,967,295 (2^32 -1)
    long------------------4字节-------(-2,147,483,648 (- 2^31) 到 2,147,483,647 (2^31 - 1)
    signed long--------4字节-------(-2,147,483,648 (- 2^31) 到 2,147,483,647 (2^31 - 1)
    unsigned long ----4字节--------0 到 4,294,967,295 (2^32 - 1)
    longlong------------8字节-------(-9223372036854775808–9223372036854775807)
    unsigned
    long*long–8字节----0~1844674407370955161615

    2、整型常量:整型常量即整型数据,可正可负,在c语言中,整型常量有二进制整数,八进制整数和十六进制整数三种形式。
    扩展整型常量的表示法,常用添加后缀来实现。
    3、整数的存储;
    整数在计算机中以二进制补码形式存储,对于无符号数(大于0)直接以补码的形式存储;对于有符号数,最左边的数(也称为最高位)表示符号为,1表示负,0表示正。

    二、字符类型
    1、字符变量;字符型变量用来存放程序中使用的字符型数据。字符型变量通过char来定义,例如;char**c;
    代码演示:

    #include<stdio.h>
    #include<stdlib.h>
    int main()
    {
    	char a,b,c,d;
    	unsigned char e;
    	a=97;
    	b='a';
    	c=-28;
    	d=a+1;  //字符型做算术运算
    	e=228;
    	printf("a=%c\n",a);
    	printf("a=%d\n",a);
    	printf("a=%c\n",b);
    	printf("a=%d\n",b);
    	printf("a=%c\n",c);
    	printf("a=%c\n",e);
    	printf("a=%c\n",d);
    	system("pause");
    	return 0;
    }
    

    2、字符常量:

    1. 字符常量是用单引号(’’)括起来的单个字符。例如:char c1 = ‘a’; char c3 = ‘9’;
    2. C 中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如:char c3 = ‘\n’; // '\n’表示换行符
    3. 在 C 中,char 的本质是一个整数,在输出时,是 ASCII 码对应的字符。
    4. 可以直接给 char 赋一个整数,然后输出时,会按照对应的 ASCII 字符输出 [97]
    5. char 类型是可以进行运算的,相当于一个整数,因为它都对应有 Unicode 码.
      6)转义字符--------意义------------ASCII码值(十进制)
      \a----------------响铃(BEL)--------------------------------------007
      \b----------------退格(BS) ,将当前位置移到前一列------008
      \f-----------------换页(FF),将当前位置移到下页开头----012
      \n----------------换行(LF) ,将当前位置移到下一行开头–010
      \r-----------------回车(CR) ,将当前位置移到本行开头----013
      \t-----------------水平制表(HT) (跳到下一个TAB位置)–009
      \v----------------垂直制表(VT)------------------------------------011
      \\(两条斜杠)------代表一个反斜线字符’’’-------092
      \’(单斜杠)----------代表一个单引号(撇号)字符---------039
      \"(单斜杠)----------代表一个双引号字符--------------------034
      \?(单斜杠)----------代表一个问号----------------------------063
      \0----------------空字符(NUL)-------------------------------------000
      \ddd----------1到3位八进制数所代表的任意字符-三位八进制
      \xhh----十六进制所代表的任意字符---------十六进制
      7)代码演示:
    #include<stdio.h>
    #include<stdlib.h>
    void main(){
    	char c1='a';
    	char c2='b';
    	int num=c2+10;//结果应该是98+10=108
    	printf("c1=%d\n",c1);//
    	printf("num=%d",num);
    	system("pause");
    }
    

    3、字符在计算机中的存储

    1. 字符型 存储到 计算机中,需要将字符对应的码值(整数)找出来
      存储:字符’a’—>码值 (97)—>二进制 (1100001)—>存储()
      读取:二进制(1100001)—>码值(97)—> 字符’a’—>读取(显示)
    2. 字符和码值的对应关系是通过字符编码表决定的(是规定好)

    三、浮点型
    1、基础知识
    1)C 语言的浮点类型可以表示一个小数,比如 123.4 ,7.8 ,0.12 等等
    2)浮点型的分类:float 单精度,4 字节,精度 6 位小数;double 双精度,8 字节,精度 15位小数
    3) 关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位 , 浮点数是近视值;尾数部分可能丢失,造成精度损失。
    2、使用细节
    1)浮点型常量默认为 double 型 ;声明 float 型常量时,须后加‘f’或‘F’。声明long double时,要加后缀“l”或“L”
    2)由于浮点数在计算时会有精度损失,浮点运算的性质和数学运算不同。所以在程序设计中,尽量避免两个相等的浮点数进行计算。
    3、浮点型常量有两种表示形式;
    十进制数形式:如:5.12 512.0f .512 (必须有小数点)
    科学计数法形式:如:5.12e2 、 5.12E-2(e前e后都有数,并且e后为整数)

    四、布尔型
    1、知识点:1) C 语言标准(C89)没有定义布尔类型,所以 C 语言判断真假时以 0 为假,非 0 为真 [案例]
    2) 但这种做法不直观,所以我们可以借助 C 语言的宏定义 。
    3) C 语言标准(C99)提供了_Bool 型,_Bool 仍是整数类型,但与一般整型不同的是,_Bool 变量只能赋值为 0 或 1,
    非 0 的值都会被存储为 1,C99 还提供了一个头文件 <stdbool.h> 定义了 bool 代表_Bool,true 代表 1,false 代
    表 0。只要导入 stdbool.h ,就能方便的操作布尔类型了 , 比如 bool flag = false;[了解]
    2、代码演示:

    #include <stdio.h>
    //宏定义
    #define BOOL int
    #define TURE 1
    #define FALSE 0
    void main() {
    int isPass = -1;
    //可以使用宏定义来完成(这里大家先看下,体会一下,后面我们会详解宏定义)
    //定义一个布尔变量
    BOOL isOk = TURE; // 等价 int isOK = 0
    if(isPass) { // 0 表示假, 非 0 表示真
    printf("通过考试");
    }
    if(isOk) {
    printf("ok");
    }
    getchar();
    }
    

    ```五、基本数据类型转换
    1、自动类型转换
    1)当 C 程序在进行赋值或者运算时,精度小的类型自动转换为精度大的数据类型,这个就是自动类型转
    换。
    2)数据类型按精度(容量)大小排序为
    在这里插入图片描述
    自动类型转换细节说明:

    1. 有多种类型的数据混合运算时,系统首先自动将所有数据转换成 精度最大的那种数据类型,然后再进行计算(如
      int 型和 short 型运算时,先把 short 转成 int 型后再进行运算)。
    2. 若两种类型的字节数不同,转换成字节数大的类型,若两种类型的字节数相同,且一种有符号,一种无符号,
      则转换成无符号类型
    3. 在赋值运算中,赋值号两边量的数据类型不同时,赋值号右边的类型将转换为左边的类型, 如果右边变量的数
      据类型长度比左边长时,将丢失一部分数据,这样会降低精度,丢失的部分按四舍五入向前舍入。

    2、强制类型转换

    1)将 精度高的数据类型转换为 精度小的数据类型。使用时要加上符 强制转换符 ( ),但可能造成精度降低或溢出,格外要注意。
    2)强制类型转换一般格式如下:
    ( 类型名) 表达式
    : 什么是表达式: 任何有值都可以称为表达式,比如 1+ 2, int num = 2
    这种强制类型转换操作并不改变操作数本身。
    3)代码演示:

    #include <stdio.h>
    void main() {
    double d1 = 1.934;
    int num = (int)d1; //这里注意,不是进行四舍五入,而是直接截断小数后的部分
    //强制转换只对最近的数有效, 如果希望针对更多的表达式转换,使用()
    //int num2 = (int)3.5 * 10 + 6 * 1.5; // 3 * 10 + 6 * 1.5 = 30 + 9.0 = 39.0
    int num3 = (int)(3.5 * 10 + 6 * 1.5); // 35.0 + 9.0 = 44.0 -> int = 44
    printf("\nnum3=%d", num3); // num3 = 44
    printf("\nnum=%d d1=%f" , num, d1); // d1 仍然是 double
    getchar();
    }
    

    强制类型转换细节说明:
    1)当进行数据的从 精度高——>精度低,就需要使用到强制转换
    2) 强转符号只针对于 最近的操作数有效,往往会使用 小括号提升优先级。

    展开全文
  • C语言有5种基本的数据类型,分别 字符型、整型、单精度浮点型、双精度浮点型、空类型。 在不同操作系统或硬件平台中,这些数据类型的值域范围和所占用内存是有差异。这种差异影响了C语言可移植性能,但...

    C语言有5种基本的数据类型,分别为 字符型整型单精度浮点型双精度浮点型空类型

    在不同的操作系统或硬件平台中,这些数据类型的值域范围和所占用的内存是有差异的。这种差异影响了C语言的可移植性能,但如果能深入理解数据类型的构成,则可以最大程度避免该问题。

     

    2.1.1 基本数据类型的字长与范围

    字长是指数据所占用内存的数量,字长决定了数据类型的值域,即范围。以字符型为例,ANSI C标准中的字符型的长度是 1 字节(8位二进制编码),可计算其值域为 -2的7次方 - +2的7次方,取值范围为 -128~127。
    计算机所使用的ASCII字符编码共有 128 个元素,所以用字符型可将全部元素表示出来。依次类推,ANSI C 标准中其他基本类型的字长与范围如下表所示:

    ANSI C标准基本类型的字长与范围
    基本类型 字长 范围
    char(字符型) 1字节 -128~127
    int(整型) 2字节 -32768~32767
    float(单精度浮点型) 4字节 约精确到6位数
    double(双精度浮点型) 8字节 约精确到12位数
    void(空值型) 0字节 无值

    由于硬件平台和操作系统的不同,数据类型的字长可能与上表不同。例如,运行在AMD64架构的Linux系统中,整型的长度为 4 字节。要获得当前系统环境中数据类型的字长,可运行下列程序。

    #include <stdio.h>
    
    int main()
    {
    	printf("字符型字长为%d\n", sizeof(char));
    	printf("整型字长为%d\n", sizeof(int));
    	printf("长整型字长为%d\n", sizeof(long));
    	printf("单精度浮点型字长为%d\n", sizeof(float));
    	printf("双精度浮点型字长为%d\n", sizeof(double));
    
    	return 0;
    }

    输出:

    字符型字长为 1
    整型字长为 4
    长整型字长为 8
    单精度浮点型字长为 4
    双精度浮点型字长为 8

    该程序使用 sizeof() 函数返回数据类型的字长,sizeof()函数的返回值为整型数据 ,返回的结果由printf()函数输出到终端中。

     

    2.1.2 聚合类型与修饰符

    C语言支持聚合类型,包括数组、指针、结构体、公用体(联合)、位域和枚举。聚合类型构成了复杂的数据结构,用以描述事物的各种属性。除 void类型 外,基本类型的前面可以有各种修饰符。修饰符用来改变
    基本类型的意义,以便更准确地适应各种情况的需求。修饰符如下:

    • signed(有符号);
    • unsigned(无符号);
    • short(短型);
    • long(长型);

    signedunsignedshortlong 修饰符适用于 字符整数 两种基本类型,而 long 还可以用于 double 。unsigned 和 signed 修饰符分别表示 无正负值符号有正负值符号 的数据类型中,
    计算机中原始数据类型使用的是二进制数,如果要表示正负值符号则需要用1位存储空间。以字符型为例,无符号字符型取值值域为 2的8次方,那么范围为 0~255,有符号字符型将1位用于存储符号,取值值域为 2的7次方,那么范围为 -128~127。下表给出所有根据 ANSI C 标准而组合的类型、字长和范围。

    ANSI C标准组合的类型、字长和范围
    类型 字长 范围
    char(字符型) 1字节 -128~127
    unsigned char(无符号字符型) 1字节 0~255
    signed char(有符号字符型) 1字节 -128~127
    int(整型) 2字节 -32 768~32 767
    unsigned int(无符号整型) 2字节 0~65 535
    signed int(有符号整型) 2字节 -32 768~32 767
    short int(短整型) 1字节 -128~127
    unsigned short int(无符短整型) 1字节 0~255
    signed short int(有符号短整型) 1字节 -128~127
    long int(长整型) 4字节 -2 147 483 648~2 147 483 647
    unsigned long int(无符号长整型) 4字节 0~4 294 967 296
    signed long int(有符号长整型) 4字节 -2 147 483 648~2 147 483 647
    float(单精度浮点型) 4字节 约精确到 6 位数
    double(双精度浮点型) 8字节 约精确到 12 位数
    void(空值型) 0字节 无值

     

    因为数据类型的默认定义是有符号数,所以 signed修饰符通常可省略。某些编译器允许将unsigned用于浮点型,如 unsigned double。但这一用法降低了程序的可移植性,故建议一般不要采用。为了使用方便,GCC编译程序允许使用整型的简写形式:short int 表示 short,即 int 可省略。

    注意:表示正数时,最大能表示的值总是比值域少 1,这是因为将 0 作为正数看待,0占用了一个取值空间。

    转载于:https://www.cnblogs.com/52php/p/5681122.html

    展开全文
  • 五种基本数据类型 基本数据类型是与硬件结构(主要是计算机的字长)直接相关的类型,是构造其他... 整型 (说明符为int ) 字符型 (说明符为char ) 浮点型 (说明符为float ) 双精度型 (说明符为double )...

    五种基本数据类型

    基本数据类型是与硬件结构(主要是计算机的字长)直接相关的类型,是构造其他派生类型的基本元件。

    C++的基本数据类型有以下几类:

      整型              (说明符为int )
         字符型            (说明符为char )
         浮点型            (说明符为float )
         双精度型         (说明符为double )
         空值型            (说明符为void)

    用修饰符形成的扩展类型

    除void类型外,其余四种基本类型的说明符之前还可以加上特定的修饰符形成扩展类型

    整型和字符型前面可加上

    signed(有符号数)

    unsigned(无符号数)

    long(长型)

    short(短型)

    双精度型前面可加上long来修饰,整型缺省为signed 。 
    当整型前面有修饰符出现时,可省略关键字int。

     float、double、long double统称为浮点类型(实型)。

    char型和int型有时可理解为同一类,因为字符在内存中是以ASCII码的形式存储的,而ASCII码值为整数。

    类型名 字长(字节) 范围
    short [int] 2 –32768 ~ 32767
    signed short [int] 2 –32768 ~ 32767
    unsigned short [int] 2 0 ~ 65535
    int 4 –2147483648 ~ 2147483647
    signed [int] 4 –2147483648 ~ 2147483647
    unsigned [int] 4 0 ~ 4294967295
    long [int] 4 –2147483648 ~ 2147483647
    signed long [int] 4 –2147483648 ~ 2147483647
    unsigned long [int] 4 0 ~ 4294967295
    char 1 –128 ~ 127
    signed char 1 –128 ~ 127
    unsigned char 1 0 ~ 255
    float 4 3.4E-38 ~ 3.4E+38
    (约7位有效数字)
    double 8 1.7E-308 ~ 1.7E+308
    (约15位有效数字)
    long double 10 3.4E-4932 ~ 1.1E+4932
    (约19位有效数字)
    void 0 无值

     常量

    常量是在程序中一经定义就不再变化的量。

    常量也具有一定的数据类型。 常量的类型是由其书写形式决定。例如,45.28是浮点类型,370是整型,‘p’是字符型等。 此外还有字符串常量和符号常量。

    字符常量

    用引号括起来的单个字符称为字符常量。例如 ‘Y’、‘y’、‘6’、‘#’、‘  ’(空格)等。

    转义序列(escape sequences)

    字符在计算机内是以二进制编码的形式存放的。ASCII码是C++使用的一种主要编码。

    ASCII码表中,除了可显示字符之外,还有一些不可显示字符,用于产生某种控制操作,例如换行符、响铃符等。

    对于不可显示的控制类字符,没有相应的图形符号,只能用另一种方法——转义序列来表示。

    转义序列有两种形式。一种是用一个反斜杠加上该字符的ASCII码来构成。其中字符的ASCII码可采用三位八进制数(形如\ddd)或两位十六进制数(形如\xhh)。 例如,换行符的ASCII码为10(八进制为12,十六进制为0A),则可表示为'\012'或'\x0A' ;

    另一种称为转义字符,由一个反斜杠后跟一个字符来表示。

    转义字符 含    义
    \a 响铃
    \n 换行符
    \r 回车符
    \t 水平制表符(tab键)
    \v 垂直制表符
    \b 退格符(backspace键)
    \\ 反斜线
    \' 单引号
    \" 双引号
    \? 问号
    \f 进页符(走纸)
    \0 空字符(null)

    整型常量

    由于计算机所能表示的整数的范围是有限的,因此整数类型事实上只是数学上所说的整数的一个子集。

     除十进制外,整型常量还可以用八进制、十六进制来表示。

    十进制整型常量没有前缀,且不能以0开头。
     
     八进制整型常量必须以0开头,其后由0~7之间的数字组成。如012、0375等。
     
     十六进制整型常量以0x或0X开头,其后由0~9之间的数字和英文字母A~Z(或a~z)组成。如0x32、0xA8等。

    整型常量可加上后缀,以区分各种不同类型的整数。具体如下:  后缀为L(或l),表示该常量为长整数(long int 型)         如:    8739L、-584l ;

     后缀为U(或u),表示该整型常量为无符号整数    (unsigned int 型)         如:     85U、20u ;

    后缀为L(或l)和U(或u)的组合,表示该常量为无符号长整数(unsigned long int 型)

          如:   6397LU、765Lu、4325lU;              07656lu(无符号八进制长整数7656)等。

    浮点常量

    浮点常量可以采用一般表示法和科学记数法表示。       科学记数法常用于表示很大或很小的浮点数。如1.2E8(即1.2×108)、-5.7356E-9(即-5.7356×10-9)。

          浮点常量的整数部分和小数部分如果为零可以省去,但不可两者都省去。 例如:  .34   456.   5.E3   .89E2 都是合法的数据。

    浮点常量可带后缀,以区分各种不同类型的实数。

        若没有后缀,表示该浮点常量为双精度数(double型),如75.23 ;     后缀为F(或f),表示该浮点常量为浮点数(float型),如4.233F、-12.9f ;     后缀为L(或l),表示该浮点常量为长双精度数(long double型),如8.5l、2.07L。

    字符串常量

    字符串常量是用双引号括起来的字符序列,又称串常量或字符串。字符串中可包含任意字符,包括空格、中文、字符的转义序列等。
    例如:
                "How are you. "
         "Thank you!\n"
              "请输入两个整数:"

    由于双引号是字符串的定界符,因此字符串本身所包含的双引号应该用其转义字符\“来表示。

    例如下面的语句: cout << "Press \"Y\" to continue or \"N\" to cancel" << endl ;

    输出为:            Press "Y" to continue or "N" to cancel

    如果字符串中含有使用反斜杠加字符的ASCII码来表示的转义序列时,C++将按最长有效长度对转义序列进行解释。

    例如,语句  cout << "x\x34y" << endl ; 由于'\x34'是字符'4'的转义序列,得到的输出为:            x4y

    字符常量可以按字符型变量同样的形式存放,在内存中只占一个字节。
        字符串常量是用一维字符数组来存放,在内存中占多个字节。每个字符串除给定的字符序列外,都有一个结束符'\0'(即ASCII码为0 的“空字符”)。

    符号常量

     

    常量除可以直接以其字面形式来表示(如3.14159)外,还可以用一个标识符来代替,用来代替常量的标识符称为符号常量。

    符号常量定义格式: const  数据类型  常量标识符 =常量表达式; const  数据类型  常量标识符 (常量表达式); 例如,下面这句             const  float  pi = 3.14159 ; 或             const  float  pi ( 3.14159 ) ;

    符号常量实际上是只读变量,由保留字const规定了它的值在程序中不能被改变。因此,符号常量又称为const变量。编译器对符号常量的处理同对变量的处理类似,但不允许修改符号常量的值,否则将导致编译错误。符号常量必须在定义的时候进行初始化,之后不能再对它赋值。

    例如,下面的语句是非法的:             const  int x=10;                 ……             x=20;               // 非法

     

    变量

    变量是存放数据的容器。
             程序设计语言中的变量是内存物理存储单元的抽象。

    变量的类型和定义

    C++中,变量必须先定义、后使用。但不一定要放在程序开头,可以在程序中随时定义、随时使用。

    变量的定义使用一个声明语句,其格式为:             类型  变量名表;

    例如,语句             int  x, y;             char  ch; 声明了两个整型变量x、y,一个字符型变量ch。

    在声明语句中变量的命名应遵循标识符的规定。例如: total、A3、is_data、Setvalue、x_ptr 都是合法的变量名。

     变量命名应尽量做到“见名知意”,并可采用适当使用下划线、相邻单词首字母大写等措施来提高程序的可读性。

    变量声明对应机器底层的实例化操作,编译器将根据指定的变量类型在内存中为每个变量分配一个存储单元。
    例如,在图3.2中,整型变量x的值为66,x 的内存地址为E320F49C。

    int  x , y ;  char  ch ;

    变量的类型—变量的长度(字节数) 变量名(存储单元首地址的映射) 变量的值—存储单元中的内容。

    变量定义实际上是指示程序为变量分配存储单元,这个分配过程也称作变量的实例化。

    变量的初始化

    在变量声明语句中为变量赋一个初值称为变量的初始化,例如:
                int  a=3, b=-78;
                double  area=67.34;
    则变量a、b、area分别被赋予初值3、-78、67.34,并将保留该值直到被修改为止。

    实例化与初始化是两个不同的操作。
    上面的语句中既有实例化也有初始化。

    C++提供另一种形式的初始化方法。

    例如,上面这两句可改写为:             int  a(3), b(-78);             double  area(67.34);

    这种形式的初始化语句中也包含了实例化。

    对比:常量定义中必然包含初始化:
    const  float  pi ( 3.14159 ) ;

    变量的赋值

    变量值的改变通过赋值运算来完成。 “=”是赋值运算符,它的左边只能是变量标识符,右边可以是常量、变量或表达式等。

     例如,对于已声明为int型的变量x,语句             x=3+2*5;  将表达式3+2*5的值13赋给x,即装入x的存储区域中。

    注意:

     1. 赋值运算符“=”不是数学上的等号,不代表等于的意思。

     2. 赋值运算符是从右到左结合的。 例如表达式    x=y=5; 相当于       y=5;              x=y;

    例    计算圆的面积
        # include <iostream.h>
        void  main()
        {
             const  double  pi = 3.1415926 ;      //const 表示常量,后面的不会改变
             double  radius , area ;         //面积和周长
             cout << "Please enter radius:" ; //提示语
             cin >> radius ;                     //输入半径
             area = pi * radius * radius ;           // 面积 = pi乘以半径的平分
             cout << "The area is:" << area << endl ; //输出
        }

     

     

     

     

     

     

     

     

     

     

    转载于:https://www.cnblogs.com/GodPan/articles/3227474.html

    展开全文
  • C++数据类型简析

    2016-06-01 11:32:00
    浮点型(又称实型),说明符为float(单精度),double(双精度); 空值型,说明符为void,用于函数和指针。 为了满足各种情况需要,除了void型外,上述三种类型前面还可以加上修饰符改变原来含义。 ...
  • python变量数据类型总结

    千次阅读 2017-03-09 16:59:02
    python脚本核心是关键字,变量,流程控制与编程思想. 变量也有三要素:变量名称,变量数据类型,变量操作方法(操作,操作函数)。 python数据类型,按照特征可以划分4个... 双精度浮点型 复数 decimal(不是
  • 字符型占位基本数据类型有整型(int),短整型(short),长整型(long),单精度浮点型(float),双精度浮点型(double),字符型(char)本人原创通俗解释:有“整”字代表整数,有“点”字代表有小数,常量具体...
  • C/C++中float与double范围和精度详解

    千次阅读 2019-04-29 14:00:40
    double-双精度浮点型 float与double都是浮点类型,double精度是float俩倍,所以double比float存的数据更精确,占空间也更大。 通常来说,float占4个字节,double占8个字节。 浮点类型在内存中用指数形式...
  • 变量命名可由字母和数字组成,对大小写敏感,但必须以字母开头,且不能与关键字重名. C语言中提供4种基本的数据类型: int 整型 char 字符型 float 单精度浮点型 double 双精度浮点型 还提供了short和long两个限定来...
  • matlab数据类型、函数

    2021-04-01 17:07:55
    class函数 转化为双精度型:如class(4)。 single函数 转化单精度:如class(single(4))。 (3)复 real函数 求复数的实部 imag函数 求复数的虚部 虚数单位可以用i和j表示。 2.数据的输出格式: format命令 ...
  • C语言字符类型

    2021-01-31 14:53:36
    字符型 短整型 整型 长整型 单精度浮点型 双精度浮点型 数据类型 char short int long float double 长 度 1 2 4 4 4 8 long型在64位环境中字符长度8 使用不同格式控制可以输出不同类型...
  • 骑士之路开启——Hello World ...(2)浮点型:float(单精度浮点型) double(双精度浮点型)→ 占位符为%f (3)字符型:char(赋值号右边值要加上单引号) → 占位符为%c 实例:int a = 10;int b = 2
  • mysqllimit

    2021-01-16 18:27:59
    double:双精度浮点型,占字节数8,用64位二进制描述,有符号是15个有效位,无符号是16个有效位 decimal:数字型,用128位二进制描述,不存在精度损失,常用于银行帐目计算。(28个有效位) 更精确浮点类型 字符...
  • JavaScript变量

    2017-04-20 18:16:04
    JavaScript中数值包含整数和浮点数,所有数值都以双精度浮点型来表示 双精度浮点数可以表示-253次方到253次方,也可以表示政府1.797610308次方最大值和政府2.2250乘以10-308次方 数值型 十...
  • MariaDB基本命令

    2019-06-11 21:21:12
    数据库表单数据类型及修饰 整型: ...DOUBLE:双精度浮点型,8字节 字符型: CHAR(#):长度#字符串,不区分大小写 BINARY(#):长度#字符产。区分大小写 VARCHAR(#):最大长度#变...
  • C/C++面试总结

    2019-05-06 10:55:42
    实型:(又称浮点型),说明符为float(单精度),double(双精度); 字符型:说明符为char; bool型:true和false C中基本数据类型 常量与变量有哪些区别 常量是平可以改变值置,变量是可以改变世...
  • 面试题:Java基础知识

    2021-01-21 16:41:42
    主题 链接 Java基础知识 面试题 ...抽象类与抽象接口重写与重载区别基本数据类型Java基本数据类型有哪些各个基本数据类型的取值范围什么是浮点型单精度和双精度有什么区别什么不能用浮点型
  • 浮点型:包含单精度型(4字节single)和双精度型(8字节double),默认使用双精度 复数型:包含实部(real)和虚部(imag,单位用i表示),都默认为双精度 数据的输出格式: format + 格式 。 默认格式short 预定义变量...
  • 数据类型分为char(字符型),int(整形),long(长整形), short(短整型),float(单精度浮点型),double(双精度浮点数)c语言是没有字符串 。 变量全局变量和局部变量,局部变量在代码块之中,作用域是...
  • 又如在例题中,使用了库函数 sin,由于系统规定其函数返回值为双精度浮点型,因此在赋值语句s=sin (x);中,s 也必须是双精度浮点型,以便与sin函数返回值一致。所以在说明部分,把s说明为双精度浮点型。但是,也有...
  • 概述 函数 查询函数(知道函数名): help+函数名 MATLAB联机帮助: helpwin 查询函数(不知道全部函数名,模糊查询): lookfor+函数信息 内存变量列表:who 内存变量信息: ...浮点型 默认双精度 ,用class(single
  • c语言入门教程.txt

    2011-05-02 16:01:56
    浮点型也可分为单精度型、双精度型和长双精度型。此外还可以分为静态变量、外部变量、寄存器变量和自动存储变量。这些数据类型我们在本节和后面章节中都会陆陆续续介绍。 那么变量我们总要给它取个名字吧,这个...
  •  5.3 双精度浮点型   5.4 复数   5.5 操作   5.5.1 混合模式操作   5.5.2 标准类型操作   5.5.3 算术操作   5.5.4 *位操作(只适用于整型)   5.6 内建函数与工厂函数   5.6.1 ...
  •  5.3 双精度浮点型   5.4 复数   5.5 操作   5.5.1 混合模式操作   5.5.2 标准类型操作   5.5.3 算术操作   5.5.4 *位操作(只适用于整型)   5.6 内建函数与工厂函数   5.6.1 ...
  • double 双精度浮点型 double val2 = ±5.0 × 10?324 ±1.7 × 10 308 0 到 255 0 到 65,535 0 到 4,294,967,295 0 到 18,446,744,073,709,551,615 ±1.5 × 10?45 ±3.4 × 10 38 到 到 4.56D;15-16 布尔型;bool ...
  • Python核心编程第二版(中文)

    热门讨论 2015-04-23 16:40:13
    5.3 双精度浮点型 5.4 复数 5.5 操作 5.5.1 混合模式操作 5.5.2 标准类型操作 5.5.3 算术操作 5.5.4 *位操作(只适用于整型) 5.6 内建函数与工厂函数 5.6.1 标准类型函数 5.6.2 数字类型函数 ...

空空如也

空空如也

1 2 3
收藏数 43
精华内容 17
关键字:

双精度浮点型数据的类型符为