精华内容
下载资源
问答
  • C语言浮点数的秘密

    千次阅读 2018-04-13 22:15:20
    --事物的难度远远低于对事物的恐惧!   通过上一章节对“有符号数与无符号数”的学习,大家知道,有符号数在计算机中以补码的形式存储,无符号数以原码的...从图中可以看到,浮点数存储分为三段:符号位、指数、...

    --事物的难度远远低于对事物的恐惧!  

            通过上一章节对“有符号数与无符号数”的学习,大家知道,有符号数在计算机中以补码的形式存储,无符号数以原码的形式存储。那么浮点数在内存中又是以什么样的方式存储?有什么不为人知的特性?本章节,就来剖一剖浮点数这个家伙!

        首先我们通过一张图来展示浮点数在内存中的存储方式

        

    从图中可以看到,浮点数存储分为三段:符号位、指数、尾数。浮点数的符号位跟有符号整数一样,都是把最高位作为符号位(1为负数0位正数),至于指数跟尾数,由于float与double所占的内存空间大小不一样,所以指数跟尾数的位数也不一样,继而二者能表示数值范围跟精度都不一样。

            上边说的有点虚,下边我们用个示例来说明,浮点数是如何在内存中存储的。

    浮点数的转换步骤分为如下三步:

            1、将浮点数转换成二进制

            2、用科学计数法表示二进制浮点数

            3、计算指数偏移后的值

    对于第3点:计算指数时需要加上偏移量,而偏移量的值与浮点数的类型有关(float偏移量值为127,double偏移量值为1023)。比方对于指数6,float与double类型偏移后的值分别为:

            float : 127 + 6 = 133

            double:1023 + 6 = 1029

    说完了转换步骤,下边我们以一个实例来展示浮点数在内存中的表示。

        实例:将float型的浮点数8.25在内存中如何表示

        第一步:先将8.25转换为二进制 -> 1000.01

        第二步:将转换的二进制用科学计数法表示 -> 1.00001 * (2^3)

        第三步:计算指数偏移后的值 -> 127 + 3 = 130 -> 100000010

    经过以上三步,就可以得出:

        a、符号位:0

        b、指数:100000010

        c、小数:00001

    所以float型的8.25在内存中的表示为:

        0 100000010 0000100000000000000000 ->0x41040000

    理论分析完了,现在我们用代码来实践下,看是不是如我们所想的一样。因为int与float在内存中都占4个字节,所以我们可以用一个int指针p,指向float变量,然后以十六进制打印出指向的四个内存中的值,代码如下:

    #include <stdio.h>
    
    int main()
    {
    	float f = 8.25;
    
    	unsigned int* p = (unsigned int*)&f;
    
    	printf("0x%08X\n", *p);
    
    	return 0;
    }

    输出结果为:跟我们分析的一样

     

    虽然实验跟我们分析的一样,但是,我们来想想下边这个问题:

     

    int类型的取值范围为 [-2^31, 2^31 - 1]

    float类型的取值范围为[-3.4*10^38, 3.4*10^38]

    那么问题就是,int与float同样是占4个字节,为什么float所能表示的数值范围比int的要大很多?

        答案揭晓:

        1、float能表示的具体数字个数与int型相同,因为都是占了4个字节的内存。

        2、重点就在于,float可表示的数字之间是不连续的,存在间隙,所以能表示比int型更大的数值。

        3、float只能作为一种近似的表示法,不能精确的表示某个数值。

        4、因为float表示的数字是不连续的,所以内存里表示相对int来说,比较复杂 ,从而运算速度也比int慢的多。

    同理:因为double与float在内存中具有相同的表示法,所以double也是不精确的,double占用内存多,精度也会比float相对高些。

    下边重点来验证下浮点类型的不精确性

    #include <stdio.h>
    
    int main()
    {
    	float f = 3.1415f;
    	float fl = 123456789;
    
    	printf("%0.10f\n", f);
    	printf("%0.10f\n", fl);
    
    	return 0;
    }

    从输出结果就表明:浮点数是不精确的表示法,不能精确的表示某个数值。

     

     

     

    留一个有趣的问题:对于两个浮点数,float f1 与 float f2,如何比较f1与f2的大小是否相等?

    总结:

        1、浮点类型与整数类型的内存表示法不同

        2、浮点类型的内存表示更复杂

        3、浮点类型可表示的数值范围更大

        4、浮点类型是一种不精确的类型

        5、浮点类型的运算速度较慢

     

    展开全文
  • Linux系统下用C语言实现浮点数四则运算表达式的求... 操作数是浮点数,可以小数形式或指数形式表示,如123.456和1.23456E2两种表示形式3. C语言实现,在linux平台上运行,也可以在Cygwin上运行4. 用命令行方式输入操作

    Linux系统下用C语言实现浮点数四则运算表达式的求值

     

    实现功能:

    1. 支持任意长度四则运算表达式,允许的操作符是:"+","-","*","/","(",")",以“#”或“=”结束表达式的输入
    2. 操作数是浮点数,可以小数形式或指数形式表示,如123.456和1.23456E2两种表示形式
    3. C语言实现,在linux平台上运行,也可以在Cygwin上运行
    4. 用命令行方式输入操作符和操作数

    5.共两个文件:头文件和源代码文件

     

    文件1: EvaluateExpression.c

    -----------------------FILE: EvaluateExpression.c BEGIN--------------------------------------------------

    /**
    * File Name:           EvaluateExpression.c
    * Description:         This file implements the function of the basic arithmetic calculations.
    *                           All valid/acceptable operations are only addition,subtraction,multiplication,division.
    *                           The valid operators are defined as {'+', '-', '*', '/', '(', ')', '#'}.
    *                           The '#' sign is defined as the ending symbol of experession input.
    *                           And it surpports the float oprand type only now.
    *
    * Author:                Sean.Wang
    * Contact Mail:        Sean.Gn@gmail.com
    * Completed Date:  July 05, 2009
    **/

    #include "EvaluateExpression.h"

    int main ( void )
    {
            float result = 0.0F;

            printf ( "/nPlease enter an expression to evaluate,and ends with the pound sign:/n" );
            result = ( float ) FloatEvaluateExpression();
            printf ( "Its result:%f/n", result );
            return 0;
    }


    /**
    * Function Name:  FloatEvaluateExpression(void)
    * Description: Implementing the float operations of addition,subtraction,multiplication,division.
    * Arguments: void
    * Returns: float
    **/
    float FloatEvaluateExpression ( void )
    {
            STACK *sOPTR = ( STACK * ) malloc ( sizeof ( STACK ) ); /* sOPTR:Operator Stack*/
            STACK *sOPND = ( STACK * ) malloc ( sizeof ( STACK ) ); /* sOPND:Operand Stack*/
            char c = ' ';
            char lastchar = ' ';
            float a = 0.0F;
            float b = 0.0F;
            char theta = ' ';
            float result = 0.0F;
            float valf = 0.0F; /*the float value of the digital string input from STDIN*/
            char strf[MAXLENGTH] = {'/0'}; /*the valid float string input from STDIN*/
            int idx = 0;
            bool pointAvail = TRUE; /*Decimal Point available*/
            bool expAvail = TRUE; /*Exponent available*/

            InitStack ( sOPTR );
            Push ( sOPTR, '#' );
            lastchar = '#';
            InitStack ( sOPND );
            c = getchar();

            while ( c != '#' || ( ( char ) GetTop ( sOPTR ) ) != '#' )
            {
                    while ( isspace ( c ) )
                            c = getchar();

                    if ( c == '=' )
                            c = '#';

                    idx = 0;
                    if ( ( c == '-' || c == '+' ) && ( IsOprator ( lastchar ) ) )
                    {
                            strf[idx++] = c;
                            c = getchar();
                            if ( ! ( isdigit ( c ) || c == '.' ) )
                            {
                                    printf ( "EXIT_FAILURE: format is invalid or undefined,!/n" );
                                    exit ( EXIT_FAILURE );
                            }
                    }
                    strf[idx] = '/0';

                    if ( isdigit ( c ) || c == '.' )
                    {
                            lastchar = '0';
                            pointAvail = TRUE; /*Decimal Point available*/
                            expAvail = TRUE; /*Exponent available*/

                            do
                            {
                                    if ( c == '.' )
                                    {
                                            if ( !pointAvail )
                                            {
                                                    printf ( "ERROR: Decimal Point not available more than once in a float data!/n" );
                                                    return ERROR;
                                            }
                                            else
                                            {
                                                    strf[idx++] = c;
                                                    pointAvail = FALSE;
                                                    continue;
                                            }
                                    }

                                    if ( c == 'e' || c == 'E' )
                                    {
                                            if ( !expAvail )
                                            {
                                                    printf ( "ERROR: Exponent s not available more than once in a float data!/n" );
                                                    return ERROR;
                                            }
                                            else
                                            {
                                                    strf[idx++] = c;
                                                    expAvail = FALSE;
                                                    c = getchar();
                                                    if ( isdigit ( c ) || c=='+' || c=='-' )
                                                            strf[idx++] = c;
                                                    else
                                                    {
                                                            printf ( "EXIT_FAILURE:'E' or 'e' followed only by digit or '+' or '-'!/n" );
                                                            exit ( EXIT_FAILURE );
                                                    }
                                                    continue;
                                            }
                                    }

                                    if ( isdigit ( c ) || c == '.' || c == 'e' || c == 'E' )
                                            strf[idx++] = c;
                                    else
                                            break;
                            }
                            while ( ( c = getchar() ) );

                            strf[idx++] = '/0';
                            valf = ConvertFloatValue ( strf );
                            Push ( sOPND, valf );
                    }
                    else if ( IsOprator ( c ) )
                    {
                            lastchar = c;
                            if ( ( sOPTR->top == NULL ) && ( sOPND->top != NULL ) )
                                    return Pop ( sOPND );
                            switch ( Precede ( ( char ) GetTop ( sOPTR ), c ) )
                            {
                                    case '<' :
                                    {
                                            Push ( sOPTR, c );
                                            c = getchar();
                                            break;
                                    }
                                    case '=' :
                                    {
                                            Pop ( sOPTR );
                                            c = getchar();
                                            break;
                                    }
                                    case '>' :
                                    {
                                            theta = ( char ) Pop ( sOPTR );
                                            b = ( float ) Pop ( sOPND );
                                            a = ( float ) Pop ( sOPND );
                                            Push ( sOPND, Operate ( a, theta, b ) );
                                            break;
                                    }

                                    default: printf ( "ERROR: Please check if this operator or expression format is invalid or undefined!/n" );
                                            return ERROR;

                            }

                    }
                    else
                    {
                            printf ( "ERROR: Please check if this oprands/operators/expression format is invalid or undefined,!/n" );
                            return ERROR;

                    }
            }


            result = ( float ) GetTop ( sOPND );

            DestroyStack ( sOPTR );
            DestroyStack ( sOPND );
            free ( sOPTR );
            free ( sOPND );
            return result;

    }


    /*Basic Operating Functions on stack.*/
    /*Initializing a stack*/
    STATUS InitStack ( STACK *s )
    {
            /*STACK *s = ( STACK * ) malloc ( sizeof ( STACK ) );*/
            if ( s != NULL )
            {
                    s->top=NULL;
                    return OK;
            }

            printf ( "ERROR:Failed to initialize stack!/n" );
            return ERROR;
    }

    /*Destroying a stack*/
    STATUS DestroyStack ( STACK *s )
    {
            STACKNODE *snode=NULL;
            assert ( s != NULL );

            while ( s->top != NULL )
            {
                    snode = s->top;
                    s->top = s->top->prior;
                    free ( snode );
                    snode = NULL;
            }

            free ( s );
            s=NULL;
            return OK;
    }

    /*Push an element in stack*/
    STATUS Push ( STACK *s, ELEMTYPE e )
    {
            assert ( s != NULL );
            STACKNODE *snode= ( STACKNODE * ) malloc ( sizeof ( STACKNODE ) );
            if ( snode == NULL )
            {
                    printf ( "ERROR:Failed to allocate memory for a new stack node!/n" );
                    return ERROR;
            }

            snode->data = e;
            snode->prior = s->top;
            s->top = snode;

            return OK;
    }

    /*Pop the top element out of stack*/
    ELEMTYPE Pop ( STACK *s )
    {
            STACKNODE *snode = NULL;
            ELEMTYPE e;
            assert ( s != NULL );

            if ( s->top == NULL )
            {
                    printf ( "EXIT 0:Invalid to Pop() on empty stack!/n" );
                    exit ( EXIT_FAILURE );
            }

            e = s->top->data;
            snode = s->top;
            s->top = s->top->prior;
            free ( snode );
            snode = NULL;

            return e;
    }

    /*get the top element in the stack*/
    ELEMTYPE GetTop ( const STACK *s )
    {
            assert ( s != NULL );
            if ( s->top == NULL )
            {
                    printf ( "EXIT 0:Failed to GetTop() on empty stack!/n" );
                    exit ( EXIT_FAILURE );
            }

            return s->top->data;
    }


    /*Convert digital string to the float value.*/
    float ConvertFloatValue ( const char *str )
    {
            assert ( str != NULL );
            float value = 0.0F;
            float integerPart = 0.0F;
            float fractionPart = 0.0F;
            float exponentPart = 1.0F;
            int expSign = POSITIVE; /*Flag sign of the exponent,negative or positive nuber*/
            int valSign = POSITIVE; /*Flag sign of the float value, negative or positive nuber*/
            int exp = 0; /*the exponent of the float value*/
            int n=0;

            while ( *str == ' ' )
                    str++;

            if ( *str == '-' )
            {
                    valSign = NEGATIVE;
                    str++;
            }
            else if ( *str == '+' )
            {
                    valSign = POSITIVE;
                    str++;
            }
            else
            {
                    ;/*null*/
            }

            for ( integerPart = 0.0F; ( str != NULL ) && ( isdigit ( *str ) ); str++ )
            {
                    integerPart *= 10;
                    integerPart += ( *str-'0' );
            }

            if ( *str == '.' )
            {
                    str++;

                    for ( fractionPart = 0.0F, n=1; ( ( str != NULL ) && ( isdigit ( *str ) ) ); str++ )
                    {
                            fractionPart += ( *str-'0' ) / Power10 ( n++ );
                    }

            }

            if ( *str == 'e' || *str == 'E' )
            {
                    str++;
                    if ( !isdigit ( *str ) )
                    {
                            switch ( *str )
                            {
                                    case '-':
                                            expSign = NEGATIVE;
                                            str++;
                                            break;
                                    case ' ':
                                    case '+':
                                            expSign = POSITIVE;
                                            str++;
                                            break;

                                    default:
                                            printf ( "ERROR:'E' or 'e' followed by an unacceptable symbol:%c in the float string!/n", *str );
                                            return ERROR;
                            }
                    }

                    for ( exp = 0, n = 0; ( ( str != NULL ) && ( isdigit ( *str ) ) ); str++ )
                    {
                            exp *=10;
                            exp += ( *str-'0' );

                    }

                    exponentPart = ( float ) Power10 ( expSign*exp );
            }

            value = ( float ) ( valSign * ( integerPart + fractionPart ) * exponentPart );

            return value;
    }


    /*the operation with the theta operator on oprand a and oprand b*/
    float Operate ( float a, char theta, float b )
    {
            switch ( theta )
            {
                    case '+':
                            return a+b;
                            break;
                    case '-':
                            return a-b;
                            break;
                    case '*':
                            return a*b;
                            break;
                    case '/':
                            if ( b < FLT_EPSILON && b > ( 0 - FLT_EPSILON ) )
                                    printf ( "Warring:potentially divide by zero exception./n" );
                            return a/b;
                            break;

                    default : printf ( "Warring:It is an unacceptable operations with the %c opertor!/n",theta );
            }

            return ERROR;
    }


    /*define the priority of the operators*/
    char Precede ( char a,char c )
    {
            int i,j;
            char b[7][7]=
            {
                    {'>', '>', '<', '<', '<', '>', '>'},
                    {'>', '>', '<', '<', '<', '>', '>'},
                    {'>', '>', '>', '>', '<', '>', '>'},
                    {'>', '>', '>', '>', '<', '>', '>'},
                    {'<', '<', '<', '<', '<', '=', ' '},
                    {'>', '>', '>', '>', ' ', '>', '>'},
                    {'<', '<', '<', '<', '<', ' ', '='}
            };

            switch ( a )
            {
                    case '+' : i=0;break;
                    case '-' : i=1;break;
                    case '*' : i=2;break;
                    case '/' : i=3;break;
                    case '(' : i=4;break;
                    case ')' : i=5;break;
                    case '#' : i=6;break;

                    default:
                            printf ( "ERROR:Oprator %c invalid or unacce!/n", a );
                            break;
            }

            switch ( c )
            {
                    case '+' : j=0; break;
                    case '-' : j=1; break;
                    case '*' : j=2; break;
                    case '/' : j=3; break;
                    case '(' : j=4; break;
                    case ')' : j=5; break;
                    case '#' : j=6; break;

                    default:
                            printf ( "ERROR:Oprator %c invalid or unacce!/n", c );
                            break;

            }

            switch ( b[i][j] )
            {
                    case '>':
                    case '<':
                    case '=':
                            return b[i][j];

                    default: printf ( "ERROR: expression format may be invalid or undefined!/n" );
                            return ERROR;
            }

    }

    /*verify if c is in the oprator list */
    bool IsOprator ( char c )
    {
            switch ( c )
            {
                    case '+':
                            return TRUE;
                    case '-':
                            return TRUE;
                    case '*':
                            return TRUE;
                    case '/':
                            return TRUE;
                    case '#':
                            return TRUE;
                    case '(':
                            return TRUE;
                    case ')':
                            return TRUE;
                            break;

                    default:return FALSE;
            }
            return ERROR;
    }

    float Power10 ( int n )
    {
            float val = 1;
            while ( n>0 )
            {
                    val = val * 10;
                    n--;
            }
            while ( n<0 )
            {
                    val = val / 10;
                    n++;
            }
            if ( n == 0 )
                    return val;

            return ERROR;
    }

    -----------------------FILE: EvaluateExpression.c END--------------------------------------------------

     

    文件2: EvaluateExpression.h
    -----------------------FILE: EvaluateExpression.c BEGIN--------------------------------------------------

    #ifndef __EVALUATEEXPRESSION_H__
    #define __EVALUATEEXPRESSION_H__

    #include <stdio.h>
    #include <ctype.h>
    #include <malloc.h>
    #include <math.h>
    #include <float.h>
    #include <stdlib.h>
    #include <assert.h>

    #define OK 1
    #define ERROR 0
    #define NEGATIVE -1
    #define POSITIVE 1
    #define TRUE 1
    #define FALSE 0
    #define MAXLENGTH 100
    /*#define FLT_EPSILON (1E-5)*/

    typedef int STATUS;
    typedef float ELEMTYPE;
    typedef int bool;

    typedef struct STACKNODE
    {
            ELEMTYPE data;
            struct STACKNODE *prior;
    }STACKNODE;

    typedef struct STACK
    {
            STACKNODE *top;
    }STACK;

    STATUS InitStack ( STACK *s );
    STATUS DestroyStack ( STACK *s );
    STATUS Push ( STACK *s, ELEMTYPE e );
    ELEMTYPE Pop ( STACK *s );
    ELEMTYPE GetTop ( const STACK *s );

    float FloatEvaluateExpression ( void );
    float ConvertFloatValue ( const char *str );
    float Operate ( float a, char theta, float b );
    char Precede ( char a,char c );
    bool IsOprator ( char c );
    float Power10 ( int n );

    #endif

    -----------------------FILE: EvaluateExpression.c END--------------------------------------------------

    展开全文
  • 它有二种形式:十进制小数形式和指数形式。 实数的表示: 十进制数形式 由数码0~ 9和小数点组成。 例如:0.0、25.0、5.789、0.13、5.0、300.、-267.8230 等均为合法的实数。 注意,必须有小数点。 指数形式 由十...

    C语言实型数据的存在形式以及合法性(浮点数):

    参考文章: C语言中文网

    实型数据也称为浮点数或实数。在C语言中,实数只采用十进制。它有二种形式:十进制小数形式和指数形式。
    实数的表示:

    1. 十进制数形式
      由数码0~ 9和小数点组成。 例如:0.0、25.0、5.789、0.13、5.0、300.、-267.8230 等均为合法的实数。

    注意,必须有小数点。

    1. 指数形式
      由十进制数,加阶码标志“e”或“E”以及阶码(只能为整数,可以带符号)组成。其一般形式为:
      a E n(a为十进制数,n为十进制整数)
      其值为 a10n。如:
      2.1E5 (等于2.1
      105)
      3.7E-2 (等于3.710-2)
      0.5E7 (等于0.5
      107)
      -2.8E-2 (等于-2.8*10-2)

    以下不是合法的实数:
    345 (无小数点)
    E7 (阶码标志E之前无数字)
    -5 (无阶码标志)
    53.-E3 (负号位置不对)
    2.7E (无阶码)
    在这里插入图片描述

    展开全文
  • 它有二种形式:十进制小数形式和指数形式。 实数的表示 1) 十进制数形式 由数码0~ 9和小数点组成。 例如:0.0、25.0、5.789、0.13、5.0、300.、-267.8230 等均为合法的实数。 注意,必须有小数点。 2) ...
    实型数据也称为浮点数或实数。在C语言中,实数只采用十进制。它有二种形式:十进制小数形式和指数形式。
    

    实数的表示

    1) 十进制数形式
    由数码0~ 9和小数点组成。 例如:0.0、25.0、5.789、0.13、5.0、300.、-267.8230 等均为合法的实数。

    注意,必须有小数点。

    2) 指数形式
    由十进制数,加阶码标志“e”或“E”以及阶码(只能为整数,可以带符号)组成。其一般形式为:
        a E n(a为十进制数,n为十进制整数)
    其值为 a*10n。如:
    2.1E5 (等于2.1*105)
    3.7E-2 (等于3.7*10-2)
    0.5E7 (等于0.5*107)
    -2.8E-2 (等于-2.8*10-2)

    以下不是合法的实数:
    345 (无小数点)
    E7 (阶码标志E之前无数字)
    -5 (无阶码标志)
    53.-E3 (负号位置不对)
    2.7E  (无阶码)

    【例3-5】输出实数。
    1. #include <stdio.h>
    2. int main(void){
    3. printf("%f\n ",356.);
    4. printf("%f\n ",356);
    5. printf("%f\n ",356.0);
    6. return 0;
    7. }
     3) 实数在内存中的存放形式
    实数一般占4个字节(32位)内存空间。按指数形式存储。实数3.14159在内存中的存放形式如下:


    说明:
    • 小数部分占的位(bit)数愈多,数的有效数字愈多,精度愈高。
    • 指数部分占的位数愈多,则能表示的数值范围愈大。

    实型变量

    实型变量分为:单精度(float型)、双精度(double型)和长双精度(long double型)三类。

    在VC6.0中单精度型占4个字节(32位)内存空间,其数值范围为3.4E-38~3.4E+38,只能提供七位有效数字。双精度型占8 个字节(64位)内存空间,其数值范围为1.7E-308~1.7E+308,可提供16位有效数字。
    类型说明符 比特数(字节数) 有效数字 数的范围
    float 32(4) 6~7 10-37~1038         
    double 64(8) 15~16 10-307~10308
    long double 128(16) 18~19 10-4931~104932
     
    实型变量定义的格式和书写规则与整型相同。例如:
    1. float x,y; // x,y为单精度实型量
    2. double a,b,c; // a,b,c为双精度实型量

    实数的舍入误差

    由于实数是由有限的存储单元组成的,因此能提供的有效数字总是有限的。如下例。

    【例3-6】实数的舍入误差。
    1. #include <stdio.h>
    2. int main(void){
    3. float a,b;
    4. a=123456.789e5;
    5. b=a+20;
    6. printf("a=%f\n",a);
    7. printf("b=%f\n",b);
    8. return 0;
    9. }
    注意:1.0/3*3的结果并不等于1。

    【例3-7】
    1. #include <stdio.h>
    2. int main(void){
    3. float a;
    4. double b;
    5. a=33333.33333;
    6. b=33333.33333333333333;
    7. printf("a=%f\nb=%f\n",a,b);
    8. return 0;
    9. }

    从本例可以看出:
    • 由于a 是单精度浮点型,有效位数只有七位。而整数已占五位,故小数二位后之后均为无效数字。
    • b 是双精度型,有效位为十六位。但VC6.0规定小数后最多保留六位,其余部分四舍五入。

    注意:实型常数不分单、双精度,都按双精度double型处理。
    展开全文
  • 一、小数的表示 小数分为整数部分和小数部分,它们由点号.分隔,例如0.0、75.0、4.023、0.27、-937.198 -...但是在书写时,C语言中的指数形式和数学中的指数形式有所差异。C语言中小数的指数形式为 aEn 或 aen ..
  • C语言printf格式化输出修饰符 printf()的格式符 转换说明 输出 %a,%A 浮点数、十六进制数和p-计数法(C99) %c 一个字符 %d 有符号十进制数 %e,%E 浮点数,e计数法 %f 浮点数,十进制计数法 %g,%G ...
  • C语言浮点型字面值常量的书写形式

    万次阅读 2018-10-10 20:44:05
    C语言浮点型字面值常量的书写形式: 浮点数字面量总是写成10进制的形式。 浮点数字面量必须有一个小数点或一个指数。如:1e10。 浮点数字面值在缺省情况下都是double类型的。 ANSI标准规定的浮点数所能容纳的...
  • 小数也称实数或浮点数。...在C语言中小数的指数形式为: aEn 或 aen a 为尾数部分,是一个十进制数,n 为指数部分,是一个十进制整数,E或e是固定的字符,其值为 a×10n。例如: 2.1E5 = 2.1×105,其中2.1是尾数,5
  • c语言学习笔记

    2016-08-06 14:14:20
    %e 浮点数指数e的形式 %s 字符串  %E 浮点数指数E的形式 %u 无符号十进制整数  %f 浮点数,小数点形式 %g 输出%f与%e较短者  %o 无符号八进制整数 %G 输出%F与%E较短者  %x 无符号十六进制整数,以0~f...
  • 学习篇 | 浮点数的表示规则

    千次阅读 2019-08-12 18:02:00
    本篇博客主要讲述的是: C语言中数据『浮点数』在内存中是如何存储 目录 导语 表示形式 规定 指数 E 有三种情况 表示形式 根据国际标准 IEEE (电气和电子工程协会)754,任意一个二进制浮点数 V 可以表示...
  • C语言数据类型

    2020-03-25 10:31:21
    C语言中,实数是以指数形式存在在存储单元中,且有多种指数的表示形式。如3.1415926可以表示成如下几种形式: 3.1415926×10° 0.31415926×10¹ 0.031415926×10² …… 上述这几种形式都是代表同一个值3....
  • C语言实型数据

    千次阅读 2014-05-03 17:39:56
    它有二种形式:十进制小数形式和指数形式。 1) 十进制数形式 由数码0~ 9和小数点组成。 例如:0.0、25.0、5.789、0.13、5.0、300.、-267.8230 等均为合法的实数。 注意,必须有小数点。 2) 指数...
  • 百分号输出(%)分类 是否含有符号 进制 类型 %d 是 10 整数 %i 是 10 ...浮点数 ...浮点数(科学表示) ...浮点数指数形式并自动选择合适的输出方式输出) %G - - 浮点数指数形式) ...
  • C语言的格式输出

    2019-10-30 00:14:43
    C语言的格式输出 %u 十进制无符号整数 %f 浮点数 %s 字符串%c 单个字符%p 指针的值 %e 指数形式浮点数 %x, %X 无符号以十六进制表示的整数 %0 无符号以八进制表示的整数 %g 自动选择合适的表示法 ...
  • C语言笔记

    2018-11-11 22:47:12
    1、数字在计算机中都是以二进制储存的  2、实型常量可以称为实数,也可以称为浮点数  3、字符型常量:用一对单引号括起来的任意字符  4、 字符串常量:用一对双... 6、指数形式用e或E来代表以10为底的指数  7、...
  • C语言知识复习

    2019-03-03 08:15:52
    %e 指数形式浮点数 %x, %X 无符号以十六进制表示的整数 %0 无符号以八进制表示的整数 %g 自动选择合适的表示法 (1). 可以在&amp;amp;amp;quot;%&amp;amp;amp;quot;和字母之间插进数字表示最大场宽,插入- ...
  • C语言转换格式符

    2014-08-04 13:42:50
    %e 浮点数指数e的形式 %s 字符串 %E 浮点数指数E的形式 %u 无符号十进制整数 %f 浮点数,小数点形式 %g 输出%f与%e较短者 %o 无符号八进制整数 %G 输出%F与%E较短者 %x 无符号十六进制整数,以0~f表示 %X ...
  • C—整数与浮点数笔记

    2016-03-13 21:46:11
    整型与浮点型拥有不同的储存方式,浮点型与整型不同,它是以小数位和幂指数形式储存的。 整型:包括int/short/unsigned/long/long long/ 仅能保证short不比int长,long不比int短,long long不必long短,int所占据...
  • 二级C语言知识点

    2018-08-15 11:34:05
    字符串的输入不能使用scanf("%s",&amp;s);而应该使用gets(s) c语言中e的x方应使用exp(x) fabs()返回浮点数的绝对值 getchar()从标准stdin获取一个字符, ...指数形式,以“e”或‘E’...
  • C语言printf详细解析

    2021-01-21 18:15:37
    1.类型: 表示输出类型的格式字符 格式字符...A 浮点数、十六进制数字和p-计数法(C99)c 输出单个字符d 以十进制形式输出带符号整数(正数不输出符号)e 以指数形式输出单、双精度实数E 以指数形式输出单、双精度实数f
  • c语言基础之浮点型与字符型数据

    千次阅读 2016-09-30 19:20:22
    C语言中的浮点数就是平常所说 的实数。 一、浮点数有两种表示形式 (1)十进制小数形式(它由数字和小数点组成) (2)指数形式(字母e(或E)之前必须有数字,且e后面的指数必须为整数) 二、浮点型变量 一个浮点...
  • C语言中的实型常量

    千次阅读 2020-06-17 14:19:21
    二、指数形式C语言中,以"e"或"E"后跟一个整数来表示以10为底的幂数。其一般形式为aEn,其中a为十进制数,n为十进制整数,如:2.333可以表示为0.2333E1、2.333e0、23.33e-1。 C语言语法规定: 字母e或E之前必须要...
  • C语言%.4f代表输出小数位为4的浮点数。...其中,%f,%F,%e,%E,%g,%G 用来输入输出实数,可以用小数形式或指数形式输入输出。可以在“%”和字母之间插进数字表示最大场宽。如:%9.2f表示输出场宽为9的浮点数,...
  • C语言中,实数是以指数形式存放在存储单元中的。我们都知道实数是一个连续的无穷集合,即使在0—1这个区间也会有无穷个数,计算机会把1.0000000000001默认为1,也会把0.99999999999默认为1,这样,就会出现误差。...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 127
精华内容 50
关键字:

c语言浮点数指数形式

c语言 订阅