精华内容
下载资源
问答
  • ![图片说明](https://img-ask.csdn.net/upload/202005/26/1590484237_122302.png) 哪位大佬能告诉我这种情况下输出为什么是这个?计算机内部发生了什么?
  • C语言浮点数整数转换的分析

    万次阅读 2011-04-21 21:10:00
    这里以C语言浮点数为例,在IEEE浮点标准下,整数转换浮点数的过程做一些直观的分析和具体的实现,IEEE浮点数的标准细节详见(http://en.wikipedia.org/wiki/IEEE_754-2008)。 在C语言中,使用float和double...

     

            这里以C语言的浮点数为例,在IEEE浮点标准下,整数转换为浮点数的过程做一些直观的分析和具体的实现,IEEE浮点数的标准细节详见(http://en.wikipedia.org/wiki/IEEE_754-2008)。

     

            在C语言中,使用float和double类型数据分别对应单精度和双精度的浮点格式。以float为例,由于float是32位,int在32位机器上也是32位。因此,float必然不能对所有的int进行准确的表示。实际上,在数轴上,浮点数所能表示的数呈非均匀的分布。举例如下图。


     

                                             .     . -3  .   .  .  .-2  . . .  -1..........0.........1.. . .   . 2 .  .     .      3.       .

     

     

           图中的点代表float可表示的数,可以看出,在所能表示的数中,接近0的比较密集,远离0的则步长逐渐增大。具体的步长可以根据浮点数标准算出。

          以float为例,符号位1位,阶码8位,位数23位。由IEEE浮点的标准可知,非规格化数表示那些非常接近0.0的数。这时候,阶码域全为0.因此,非规格化数的步长为

                                                             2-23×2-127 ≈ 1.4×10-45

     

          而非规格化数的范围则约等于   -1.2×10-38 到1.2×10-38  在这个范围内,float能表示的数呈均匀分布。

           而int则处在规格化数的范围内。对于规格化数,步长不均匀。步长可表示为

     

                                                                             2-23×2E

            其中,E的取值范围是-126~+127。显然,随着E增大,步长增大。因此,对于越远离0的区域,步长越大。当E =  30时,步长为128。如下程序是一个验证。

                                      

     

     

             其中,浮点数表示230次方,刚阶码值E=30,程序中a数组记录x每次加一的结果,从输出中可以看出,因为步长为128,在0-64次相加中,并没有改变a[i]的值,而在后64次相加中,a[i]则保持为230次方+128

     

                                                                       

            因此,除了不均匀的步长以外,还需要考虑的是舍入的问题。由上面的测试中可知,C语言的舍入方法中,若整数处于步长的前半,则向下舍入,否则向上舍入。而对于刚好处于中间的数,例如上图中a[64],这种与前后的可取的数距离相等,则采用向偶数舍入的原则。即取表示成float形式后,最后一位为偶数(0)的数。

            分析到此,开始实现,说白的就是实现一个 float f = float(integer)的功能。函数原型如下:

                                                                           unsigned  float_itof(int i)  

          把整数i转换为float的表示形式,然后返回对应的4个字节。函数中不能使用float类型及其运算。

          代码如下:

                           

            对输入i进行 INT_MIN 到 INT_MAX的范围测试,与float(i)的结果逐字节比较。代码正确。

     

    展开全文
  • c语言浮点数整数转换 C中的数据类型 (Data Types in C) There are several different ways to store data in C, and they are all unique from each other. The types of data that information can be stored ...

    c语言中浮点数和整数转换

    C中的数据类型 (Data Types in C)

    There are several different ways to store data in C, and they are all unique from each other. The types of data that information can be stored as are called data types. C is much less forgiving about data types than other languages. As a result, it’s important to make sure that you understand the existing data types, their abilities, and their limitations.

    有几种不同的方法可以将数据存储在C中,并且它们彼此之间是唯一的。 可以存储信息的数据类型称为数据类型。 与其他语言相比,C对于数据类型的宽容程度要低得多。 因此,重要的是要确保您了解现有的数据类型,它们的功能及其局限性。

    One quirk of C’s data types is that they depend entirely on the hardware that you’re running your code on. An int on your laptop will be smaller than an int on a supercomputer, so knowing the limitations of the hardware you’re working on is important. This is also why the data types are defined as being minimums- an int value, as you will learn, is at minimum -32767 to 32767: on certain machines, it will be able to store even more values that this.

    C的数据类型的一个怪癖是它们完全取决于您在其上运行代码的硬件。 笔记本电脑上的int会比超级计算机上的int小,因此了解所用硬件的局限性很重要。 这也是为什么将数据类型定义为最小值的原因-正如您将学到的那样,一个int值至少为-32767到32767:在某些机器上,它将能够存储更多的值。

    There are two categories that we can break this into: integers, and floating point numbers. Integers are whole numbers. They can be positive, negative, or zero. Numbers like -321, 497, 19345, and -976812 are all perfectly valid integers, but 4.5 is not because 4.5 is not a whole number.

    我们可以将其分为两类:整数和浮点数。 整数是整数。 它们可以是正数,负数或零。 像-321、497、19345和-976812之类的数字都是完全有效的整数,但是4.5并不是因为4.5不是整数。

    Floating point numbers are numbers with a decimal. Like integers, -321, 497, 19345, and -976812 are all valid, but now 4.5, 0.0004, -324.984, and other non-whole numbers are valid too.

    浮点数是带小数的数字。 像整数一样,-321、497、19345和-976812都有效,但是现在4.5、0.0004,-324.984和其他非整数也都有效。

    C allows us to choose between several different options with our data types because they are all stored in different ways on the computer. As a result, it is important to be aware of the abilities and limitations of each data type to choose the most appropriate one.

    C允许我们在数据类型的几个不同选项之间进行选择,因为它们都以不同的方式存储在计算机上。 因此,重要的是要知道每种数据类型选择最合适的能力和局限性。

    整数数据类型 (Integer data types)

    字符: char (Characters: char)

    char holds characters- things like letters, punctuation, and spaces. In a computer, characters are stored as numbers, so char holds integer values that represent characters. The actual translation is described by the ASCII standard. Here’s a handy table for looking up that.

    char包含字符,例如字母,标点和空格。 在计算机中,字符存储为数字,因此char保留代表字符的整数值。 实际翻译由ASCII标准描述。 这是一个方便查找的桌子。

    The actual size, like all other data types in C, depends on the hardware you’re working on. By minimum, it is at least 8 bits, so you will have at least 0 to 127. Alternatively, you can use signed char to get at least -128 to 127.

    像C中的所有其他数据类型一样,实际大小取决于您正在使用的硬件。 至少,它至少是8位,因此您至少要有0到127。或者,您可以使用带signed char来获得至少-128到127。

    标准整数: int (Standard Integers: int)

    The amount of memory that a single int takes depends on the hardware. However, you can expect an int to be at least 16 bits in size. This means that it can store values from -32,768 to 32,767, or more depending on hardware.

    一个int占用的内存量取决于硬件。 但是,您可以预期int大小至少为16位。 这意味着它可以存储-32,768到32,767或更多的值,具体取决于硬件。

    Like all of these other data types, there is an unsigned variant that can be used. The unsigned int can be positive and zero but not negative, so it can store values from 0 to 65,535, or more depending on hardware.

    像所有其他所有数据类型一样,可以使用unsigned变体。 unsigned int可以是正数,可以是零,但不能为负数,因此它可以存储0到65,535之间的值,或者取决于硬件而更多。

    短整数: short (Short integers: short)

    This doesn’t get used often, but it’s good to know that it exists. Like int, it can store -32768 to 32767. Unlike int, however, this is the extent of its ability. Anywhere you can use short, you can use int.

    这并不经常使用,但是很高兴知道它的存在。 与int一样,它可以存储-32768到32767。但是,与int不同,这是其功能的程度。 只要可以使用short ,就可以使用int

    长整数: long (Longer integers: long)

    The long data type stores integers like int, but gives a wider range of values at the cost of taking more memory. Long stores at least 32 bits, giving it a range of -2,147,483,648 to 2,147,483,647. Alternatively, use unsigned long for a range of 0 to 4,294,967,295.

    long数据类型存储整数,如int ,但以占用更多内存为代价,提供了更大范围的值。 Long存储至少32位,范围为-2,147,483,648至2,147,483,647。 或者,使用unsigned long ,范围为0到4,294,967,295。

    甚至更长的整数: long long (Even longer integers: long long)

    The long long data type is overkill for just about every application, but C will let you use it anyway. It’s capable of storing at least −9,223,372,036,854,775,807 to 9,223,372,036,854,775,807. Alternatively, get even more overkill with unsigned long long, which will give you at least 0 to 18,446,744,073,709,551,615.

    long long数据类型对于几乎每个应用程序来说都是多余的,但是C仍然可以让您使用它。 它能够存储至少-9,223,372,036,854,775,807至9,223,372,036,854,775,807。 或者,使用unsigned long long获得更多的过大杀伤力,这将使您至少有0到18,446,744,073,709,551,615。

    浮点数数据类型 (Floating point number data types)

    基本浮点数: float (Basic Floating point numbers: float)

    float takes at least 32 bits to store, but gives us 6 decimal places from 1.2E-38 to 3.4E+38.

    float至少需要32位来存储,但是从1.2E-38到3.4E + 38,我们给了6个小数位。

    双打: double (Doubles: double)

    double takes double the memory of float (so at least 64 bits). In return, double can provide 15 decimal place from 2.3E-308 to 1.7E+308.

    double占用float内存的两倍(因此至少需要64位)。 作为回报,double可以提供从2.3E-308到1.7E + 308的小数点后15位。

    获得更大范围的双打: long double (Getting a wider range of doubles: long double)

    long double takes at least 80 bits. As a result, we can get 19 decimal places from 3.4E-4932 to 1.1E+4932.

    long double至少需要80位。 结果,我们可以从3.4E-4932到1.1E + 4932获得19位小数。

    选择正确的数据类型 (Picking the right data type)

    C makes pick the data type, and makes us be very specific and intentional about the way that we do this. This gives you a lot of power over your code, but it’s important to pick the right one.

    C会选择数据类型,并使我们对执行此操作的方式非常明确和有目的地。 这为您提供了很多控制代码的能力,但是选择正确的代码很重要。

    In general, you should pick the minimum for your task. If you know you’ll be counting from integer 1 to 10, you don’t need a long and you don’t need a double. If you know that you will never have negative values, look into using the unsigned variants of the data types. By providing this functionality rather than doing it automatically, C is able to produce very light and efficient code. However, it’s up to you as the programmer to understand the abilities and limitations, and choose accordingly.

    通常,您应该为任务选择最低要求。 如果您知道要从整数1到10进行计数,则不需要很长,也不需要加倍。 如果您知道永远不会有负值,请研究使用数据类型的unsigned变体。 通过提供此功能而不是自动执行,C可以生成非常轻便且高效的代码。 但是,作为程序员,您需要了解功能和限制并做出相应选择。

    We can use the sizeof() operator to check the size of a variable. See the following C program for the usage of the various data types:

    我们可以使用sizeof()运算符来检查变量的大小。 有关各种数据类型的用法,请参见以下C程序:

    #include <stdio.h>
    
    int main()
    {
        int a = 1;
        
        char b ='G';
        
        double c = 3.14;
        
        printf("Hello World!\n");
     
        //printing the variables defined above along with their sizes
        printf("Hello! I am a character. My value is %c and "
               "my size is %lu byte.\n", b,sizeof(char));
        //can use sizeof(b) above as well
     
        printf("Hello! I am an integer. My value is %d and "
               "my size is %lu  bytes.\n", a,sizeof(int));
        //can use sizeof(a) above as well
     
        printf("Hello! I am a double floating point variable."
               " My value is %lf and my size is %lu bytes.\n",c,sizeof(double));
        //can use sizeof(c) above as well
     
        printf("Bye! See you soon. :)\n");
        return 0;
    }

    输出: (Output:)

    Hello World!Hello! I am a character. 
    My value is G and my size is 1 byte.
    Hello! I am an integer. 
    My value is 1 and my size is 4 bytes.
    Hello! I am a double floating point variable. 
    My value is 3.140000 and my size is 8 bytes.
    Bye! See you soon. :)

    虚空类型 (The Void type)

    The void type specifies that no value is available. It is used in three kinds of situations:

    void类型指定没有可用值。 它在三种情况下使用:

    1.函数返回空值 (1. Function returns as void)

    There are various functions in C which do not return any value or you can say they return void. A function with no return value has the return type as void. For example, void exit (int status);

    C中有各种函数不返回任何值,或者可以说它们返回void。 没有返回值的函数的返回类型为void。 例如, void exit (int status);

    2.函数参数为void (2. Function arguments as void)

    There are various functions in C which do not accept any parameter. A function with no parameter can accept a void. For example, int rand(void);

    C中有许多不接受任何参数的函数。 没有参数的函数可以接受空白。 例如, int rand(void);

    3.指向无效的指针 (3. Pointers to void)

    A pointer of type void * represents the address of an object, but not its type. For example, a memory allocation function void *malloc( size_t size); returns a pointer to void which can be casted to any data type.

    类型为void *的指针表示对象的地址,但不表示其类型。 例如,一个内存分配函数void *malloc( size_t size); 返回指向void的指针,该指针可以转换为任何数据类型。

    翻译自: https://www.freecodecamp.org/news/data-types-in-c-integer-floating-point-and-void-explained/

    c语言中浮点数和整数转换

    展开全文
  • 学习过程中遇到了一个问题,首先定义了一个一位浮点数a = 1.5,我想把他扩大十倍,之后再缩小十倍 如下图,第一次a返回不了原来的值了 [img=https://img-bbs.csdn.net/upload/202102/18/1613619364_92778.png][/...
  • C语言浮点数

    2020-11-17 19:19:07
    文章目录一、浮点数的概念二、点用内存的情况三、浮点数的精度1、测试float类型2、测试double类型3、测试long double类型4、测试总结四、浮点数的输出五、常用的库函数六、整数转换浮点数七、应用经验八、科学计数...

    一、浮点数的概念

    浮点数也称小数或实数。例如,0.0、75.0、4.023、0.27、-937.198 都是合法的小数。

    C语言中采用float和double关键字来定义小数,float称为单精度浮点型,double称为双精度浮点型,long double更长的双精度浮点型。

    在任何区间内(如1.0 到 2.0 之间)都存在无穷多个实数,计算机的浮点数不能表示区间内所有的值。

    二、点用内存的情况

    我们先来测试一下float、double和long double三种浮点数据类型占用内存的字节数。

    示例(book71.c)

    /*
     * 程序名:book71.c,此程序测试float、double和long double占用内存的字节数
     * 作者:C语言技术网(www.freecplus.net) 日期:20190525
    */
    #include <stdio.h>
    
    int main()
    {
      printf("sizeof float is %d\n",sizeof(float));
      printf("sizeof double is %d\n",sizeof(double));
      printf("sizeof long double is %d\n",sizeof(long double));
    }
    

    运行效果

    在这里插入图片描述

    三、浮点数的精度

    C标准规定,float类型必须至少能表示6位有效数字,且取值范围至少是10-37~10+37

    double类型和 float类型的最小取值范围相同,但至少必须能表示10位有效数字。

    long double,以满足比double类型更高的精度要求。不过,C只保证long double类型至少与double类型的精度相同。

    看了上面这段文字,估计大家有点晕,在之前的整数章节中,long比int的占用的内存多,存放数据的值也就越大,并且有一个准确的范围,但是,为什么各种浮点数存放数据的值怎么就这么模糊呢?我先不解释原因,浮点数的存储方式比较复杂,暂时不讨论,先用几个程序来测试一下它们的特征。

    1、测试float类型

    示例(book73.c)

    /*
     * 程序名:book73.c,此程序测试float的特征
     * 作者:C语言技术网(www.freecplus.net) 日期:20190525
    */
    #include <stdio.h> 
    
    int main()
    {
      float ff2=9.9;   // 测试2位的浮点数
      printf("ff2=%f\n",ff2);
      if (ff2==9.9) printf("ff2==9.9\n");
    
      float ff5=99.999;   // 测试5位的浮点数
      printf("ff5=%f\n",ff5);
      if (ff5==99.999) printf("ff5==99.999\n");
    
      float ff6=999.999;   // 测试6位的浮点数
      printf("ff6=%f\n",ff6);
      if (ff6==999.999) printf("ff6==999.999\n");
    
      float ff7=9999.999;   // 测试7位的浮点数
      printf("ff7=%f\n",ff7);
      if (ff7==9999.999) printf("ff7==9999.999\n");
    
      float ff8=99999.999;   // 测试8位的浮点数
      printf("ff8=%f\n",ff8);
      if (ff8==99999.999) printf("ff8==99999.999\n");
    }
    

    运行效果

    在这里插入图片描述

    从程序的运行我们可以看出float数的两个特征:

    1)float数据类型表达的是一个近似的数,不是准确的,小数点后的n位有误差,浮点数的位数越大,误差越大,到8位的时候,误差了1,基本上不能用了。

    2)用“==”可以比较两个整数或字符是否相等,但是,看起来相等的两个浮点数,就是不会相等。

    2、测试double类型

    示例(book74.c)

    /*
     * 程序名:book74.c,此程序测试double的特征
     * 作者:C语言技术网(www.freecplus.net) 日期:20190525
    */
    #include <stdio.h> 
    
    int main()
    {
      double ff2=9.9;   // 测试2位的浮点数
      printf("ff2=%lf\n",ff2);
      if (ff2==9.9) printf("ff2与9.9相等。\n");
    
      double ff12=999999999.99;   // 测试12位的浮点数
      printf("ff12=%lf\n",ff12);
      if (ff12==999999999.99) printf("ff12与999999999.999相等。\n");
    
      double ff13=9999999999.99;   // 测试13位的浮点数
      printf("ff13=%lf\n",ff13);
      if (ff13==9999999999.99) printf("ff13与9999999999.999相等。\n");
    
      double ff14=99999999999.99;   // 测试14位的浮点数
      printf("ff14=%lf\n",ff14);
      if (ff14==99999999999.99) printf("ff14与99999999999.999相等。\n");
    
      double ff15=999999999999.99;   // 测试15位的浮点数
      printf("ff15=%lf\n",ff15);
      if (ff15==999999999999.99) printf("ff15与999999999999.999相等。\n");
    
      double ff16=9999999999999.99;   // 测试16位的浮点数
      printf("ff16=%lf\n",ff16);
      if (ff16==9999999999999.99) printf("ff16与9999999999999.999相等。\n");
    
      double ff17=99999999999999.99;   // 测试17位的浮点数
      printf("ff17=%lf\n",ff17);
      if (ff17==99999999999999.99) printf("ff17与99999999999999.999相等。\n");
    
      double ff18=999999999999999.99;   // 测试17位的浮点数
      printf("ff18=%lf\n",ff18);
      if (ff18==999999999999999.99) printf("ff17与99999999999999.999相等。\n");
    }
    

    运行效果

    在这里插入图片描述

    从程序的运行我们可以看出double数的两个特征:

    1)double数据类型表达的也是一个近似的数,不是准确的,小数点后的n位有误差,浮点数的位数越大,误差越大,到17位的时候,误差了1,基本上不能用了。

    2)用“==”可以比较两个double数值是否相等。

    3、测试long double类型

    示例(book75.c)

    /*
     * 程序名:book75.c,此程序测试long double的特征
     * 作者:C语言技术网(www.freecplus.net) 日期:20190525
    */
    #include <stdio.h> 
    
    int main()
    {
      long double ff2=9.9;   // 测试2位的浮点数
      printf("ff2=%Lf\n",ff2);
      if (ff2==9.9) printf("ff2与9.9相等。\n");
    
      long double ff12=999999999.99;   // 测试12位的浮点数
      printf("ff12=%Lf\n",ff12);
      if (ff12==999999999.99) printf("ff12与999999999.999相等。\n");
    
      long double ff13=9999999999.99;   // 测试13位的浮点数
      printf("ff13=%Lf\n",ff13);
      if (ff13==9999999999.99) printf("ff13与9999999999.999相等。\n");
    
      long double ff14=99999999999.99;   // 测试14位的浮点数
      printf("ff14=%Lf\n",ff14);
      if (ff14==99999999999.99) printf("ff14与99999999999.999相等。\n");
    
      long double ff15=999999999999.99;   // 测试15位的浮点数
      printf("ff15=%Lf\n",ff15);
      if (ff15==999999999999.99) printf("ff15与999999999999.999相等。\n");
    
      long double ff16=9999999999999.99;   // 测试16位的浮点数
      printf("ff16=%Lf\n",ff16);
      if (ff16==9999999999999.99) printf("ff16与9999999999999.999相等。\n");
    
      long double ff17=99999999999999.99;   // 测试17位的浮点数
      printf("ff17=%Lf\n",ff17);
      if (ff17==99999999999999.99) printf("ff17与99999999999999.999相等。\n");
    
      long double ff18=999999999999999.99;   // 测试17位的浮点数
      printf("ff18=%Lf\n",ff18);
      if (ff18==999999999999999.99) printf("ff17与99999999999999.999相等。\n");
    }
    

    运行效果

    在这里插入图片描述

    long double的测试结果与double相同。

    4、测试总结

    float只能表达6-7位的有效数字,不能用“==”判断两个数字是否相等。

    double能表达15-16位有效的数字,可以用“==”判断两个数字是否相等。

    long double占用的内存是double的两倍,但表达数据的精度和double相同。

    在实际开发中,建议弃用float,只采用double就可以,long double暂时没有必要,但不知道以后的操作系统和编译器对long double是否有改进。

    四、浮点数的输出

    float采用%f占位符。

    double采用%lf占位符。测试结果证明,double不可以用%f输入,但可以用%f输出,但是不建议采用%f,因为不同的编译器可能会有差别。

    long double采用%Lf占位符,注意,L是大写。

    浮点数输出缺省显示小数点后六位。

    浮点数采用%lf输出,完整的输出格式是%m.nlf,指定输出数据整数部分和小数部分共占m位,其中有n位是小数。如果数值长度小于m,则左端补空格,若数值长度大于m,则按实际位数输出。

    double ff=70001.538;
    printf("ff=%lf=\n",ff);       // 输出结果是ff=70001.538000=
    printf("ff=%.4lf=\n",ff);     // 输出结果是ff=70001.5380=
    printf("ff=%11.4lf=\n",ff);   // 输出结果是ff= 70001.5380=
    printf("ff=%8.4lf=\n",ff);    // 输出结果是ff=70001.5380=
    

    五、常用的库函数

    在接下来的内容中,我只介绍double,不再介绍float和long double两种数据类型相关的知识。

    以下是常用的浮点数函数,必须掌握。

    double atof(const char *nptr);       // 把字符串nptr转换为double
    double fabs(double x);                // 求双精度实数x的绝对值
    double pow(double x, double y);      // 求 x 的 y 次幂(次方)
    double round(double x);               // double四舍五入,是小数点后一位四舍五入
    double ceil(double x);                // double向上取整数,去掉小数,邻近的大一的数
    double floor(double x);               // double向下取整数,
    double fmod(double x,double y);      // 求x/y整除后的双精度余数
    // 把双精度val分解成整数部分和小数部分,整数部分存放在ip所指的变量中,返回小数部分。
    double modf(double val,double *ip);
    

    在这里插入图片描述
    mod:取余,所以xs=modf(dd,&zs);

    还有一些数据计算函数,如正弦、对数、指数等,实际开发中极少使用,大家要用的时候再查资料,我就不介绍了。

    六、整数转换为浮点数

    示例(book77.c)

    /*
     * 程序名:book77.c,此程序测试整数与浮点数的转换。
     * 作者:C语言技术网(www.freecplus.net) 日期:20190525
    */
    #include <stdio.h>
    
    int main()
    {
      int ii=3;
      int jj=4;
      double dd;
    
      dd=ii;        // 可以
      printf("dd is %.2lf\n",dd);
    
      dd=ii/jj;     // 不行
      printf("dd is %.2lf\n",dd);
    
      dd=(double)ii/jj;  // 可以
      printf("dd is %.2lf\n",dd);
    }
    

    运行效果

    在这里插入图片描述

    需要特别注意的是dd=ii/jj这一行代码,dd的值0,不是0.75,有点意外,所以,如果对整数转换为浮点数没有把握,加(double)强制转换是个好办法。关于数据类型的转换,在《C语言数据类型转换》章节中将有更详细的介绍。

    七、应用经验

    浮点数有一些坑,例如两个浮点数不相等和精度的问题,在实际开发中,我们经常用整数代替浮点数,因为整数是精确的,效率也更高。

    例如人的身高一米七五,以米为单位,用浮点数表示是1.75米,如果以厘米为单位,用整数表示是175。

    long整数的取值是-9223372036854775808~9223372036854775807,有效数字是19位,而double的有效数字才15-16位,所以,整数可以表达的小数更大的数,更实用,麻烦也更少。

    货币:1.75元,如果采用0.01元为单位就是175,采用0.001元为单位就是1750,如果您说要更多小数怎么办?您这是钻牛角尖。

    码农之道:高水平的程序员不容易掉坑里,注意,是不容易,不是不会,最好的方法是不要靠近坑。

    八、科学计数法

    在实际开发中,我们很少使用科学计数法,但是它经常出现在计算机系统中,例如浮点数在内存中的存放方式就是科学计数法,所以我们还是有必要学习科学计数法。

    科学记数法是一种记数的方法。把一个数表示成a与10n相乘的形式(1≤|a|<10,n为整数),这种记数法叫做科学记数法。当我们要书写或运算某个较大或较小且位数较多时,用科学记数法免去浪费很多空间和时间。

    例如:51400000000=5.14×1011,计算机表达10的幂是一般是用E或e,也就是51400000000=5.14E11或5.14e11。

    用科学记数法表示数时,不改变数的符号,只是改变数的书写形式而已,可以方便的表示日常生活中遇到的一些极大或极小的数 。如:光的速度大约是300,000,000米/秒;全世界人口数大约是:6,100,000,000,这样的数书写和显示都很不方便,为了免去写这么多重复的0,将其表现为这样的形式:6,100,000,000=6.1×109,即6.1E9或6.1e9。

    0.00001=1×10-5,即绝对值小于1的数也可以用科学记数法表示为a乘10-n的形式。即1E-5或1e-5。

    科学计数法采用%e或%E输出,完整的输出格式是%m.ne或%m.nE,指定输出数据整数部分和小数部分共占m位,其中有n位是小数。如果数值长度小于m,则左端补空格,若数值长度大于m,则按实际位数输出。

    示例(book78.c)

    /*
     * 程序名:book78.c,此程序测试浮点数据的科学计数法。
     * 作者:C语言技术网(www.freecplus.net) 日期:20190525
    */
    #include <stdio.h>
    
    int main()
    {
      double dd;
    
      dd=123000000;
      printf("dd is  %.2e\n",dd);
    
      dd=-123000000;
      printf("dd is %.2e\n",dd);
    
      dd=0.0000000123;
      printf("dd is  %.2e\n",dd);
    
      dd=-0.0000000123;
      printf("dd is %.2e\n",dd);
    }
    

    运行效果

    在这里插入图片描述

    九、课后作业

    1)编写示例程序,类似本章节的book71.c、book73.c、book74.c、book75.c、book77.c、book78.c,编译并运行它,程序员是写出来的,不是看出来的,熟能生巧,您每天的付出都有意义。

    2)编写示例程序,测试浮点数赋值超过取值范围的后果。

    3)关于浮点数在内存中的存储方式,建议大家去百度一下(搜索关键字为C语言浮点数存储方式),了解一下相关的概念。

    4)编写示例程序,测试把浮点数赋给整数变量的结果,并思考原因。

    5)本题作业建议在学完《C语言数据类型转换》后再做,因为有知识点交叉,重写浮点数的常用库函数,实现其功能,函数的声明如下:

    double FABS(const double x);          // 求双精度实数x的绝对值
    double ROUND(const double x);         // double四舍五入
    double CEIL(const double x);          // double向上取整数
    double FLOOR(const double x);         // double向下取整数
    // 把双精度val分解成整数部分和小数部分,整数部分存放在ip所指的变量中,返回小数部分。
    double MODF(double val,double *ip);  
    

    十、版权声明

    C语言技术网原创文章,转载请说明文章的来源、作者和原文的链接。
    来源:C语言技术网(www.freecplus.net)
    作者:码农有道

    如果这篇文章对您有帮助,请点赞支持,或在您的博客中转发我的文章,谢谢!!!
    如果文章有错别字,或者内容有错误,或其他的建议和意见,请您留言指正,非常感谢!!!

    展开全文
  • 1)把浮点数拆分成两部分,小数点前面的整数和小数点后面的小数。 2)分别把整数和小数部分转换为二进制,保存在字符串中。 3)输出转换后和二进制字符串。 1、整数部分转二进制字符串的方法 1)把十进数除以2,记下...

    浮点数据转换为二进制的方法是:

    1)把浮点数拆分成两部分,小数点前面的整数和小数点后面的小数。

    2)分别把整数和小数部分转换为二进制,保存在字符串中。

    3)输出转换后和二进制字符串。

    1、整数部分转二进制字符串的方法

    1)把十进数除以2,记下余数(余数保存在字符串中),现用商除以2,再记下余数,如此循环,直到商为0。

    2)把保存余数的字符串反过来,就是结果。

    例如123转化成二进制:

    123/2=61余1

    61/2=30余1

    30/2=15余0

    15/2=7余1

    7/2=3余1

    3/2=1余1

    1/1=0余1

    结果是1101111,反过来就是1111011。

    2、小数部分转二进制字符串的方法

    1)把小数乘以2,假设结果是s,如果s大于1,该位二进制值为1,如果小于1,该位二进制值为0;

    2)把上一步的结果s去掉整数位,只保留小数位,假设得到结果xs,如果xs等于0,转换结束,如果xs大于0,重复第1)步。

    例如0.2转换为二进制:

    0.2*2=0.4 0

    0.4*2=0.8 0

    0.8*2=1.6 1

    0.6*2=1.2 1

    0.2*2=0.4 0

    …… 无限循环

    浮点数123.2,转换为二进制的结果是1111011.00110011001100110011(小数点后保留20位)。

    3、示例程序

    /*
     * 程序名:book.c,此程序用于把浮点数转换为二进制的字符串。
     * 作者:C语言技术网(www.freecplus.net) 日期:20190525。
    */
    #include "stdio.h"
    #include <string.h>
    
    // 把浮点数的整数部分转换为二进制的字符串。
    // dec:待转换的浮点数的整数部分。
    // pbin:用于存放转换后的字符串的地址。
    void dectobin(const long dec,char *pbin)
    {
      long ys=0;  // 余数。
      int s=dec;  // 商。
      int ii=0;   // 位数的计数器。
      char result[65];  // 转换成二进制后,保存在result中,再反过来存放到pbin中。
    
      memset(result,0,sizeof(result));
    
      // 把浮点数的整数部分转换为二进制,存放在result中。
      while (s>0)
      {
        ys=s%2;
        s=s/2;
        result[ii]=ys+'0';
        ii++;
      }
      
      // 再把result字符串反过来,存放在pbin中。
      int jj=0;
      for (;ii>0;ii--)
      {
        pbin[jj]=result[ii-1];
        jj++;
      }
    
      pbin[jj]=0; // 出于安全的考虑,加上0表示字符串结束。
    }
    
    // 把浮点数小数部分转换为二进制的字符串。
    // decp:待转换的浮点数的小数部分。
    // pbin:用于存放转换后的字符串的地址。
    // maxp:指定pbin字符串保留的长度。
    void decptobin(const double decp,char *pbin,const int maxp)
    {
      double xs=decp;  // 小数部分。
      int qz=0;        // 取整的结果。
      int ii=0;        // 位数的计数器。
    
      while (xs>0)
      {
        qz=(int)(xs*2);      // 小数部分乘2取整。
        pbin[ii++]=qz+'0';   // 0+'0'='0',1+'0'='1'。
        xs=xs*2;             // 小数部分乘2。
        if (xs>=1) xs=xs-1;  // 如果>=1,取整。
        
        if (ii==maxp) break;
      }
    
      pbin[ii]=0;  // 出于安全的考虑,加上0表示字符串结束。
    }
    
    int main()
    {
      double ff=0;
      printf("请输入一个浮点数:");  
      scanf("%lf",&ff);
    
      char str1[101],str2[101];
      memset(str1,0,sizeof(str1));
    
      dectobin((long)ff,str1);  // 把整数部分转换为二进制,保存在str1中。
      decptobin(ff-(long)ff,str2,24);  // 把小数部分转换为二进制,保存在str2中。
    
      printf("%f的二进制输出是:%s.%s\n",ff,str1,str2);
    }
    

    运行效果
    在这里插入图片描述

    4、获取视频教程

    百万年薪程序员录制,《C/C++高性能服务开发基础》视频教程已在CSDN学院发布,优惠价12元,地址如下:
    https://edu.csdn.net/course/play/29402

    5、版权声明

    C语言技术网原创文章,转载请说明文章的来源、作者和原文的链接。

    来源:C语言技术网(www.freecplus.net

    作者:码农有道

    如果这篇文章对您有帮助,请点赞支持,或在您的博客中转发此文,让更多的人可以看到它,谢谢!!!

    展开全文
  • 1、整数部分为1位时,小数部分第7位开始失真。9.0000001经过转换后为9.000000 2、整数部分为2位时,小数部分第1位开始失真。99.100000 经过转换后为 99.099998 float ftt = atof(std::string(“99.100000”).c_str()...
  • 浮点数转换整数四舍五入Given a float value and we have to round the value to the nearest integer with the help of Macro in C language. 给定一个浮点值,我们必须借助C语言中的Macro将其舍入到最接近的...
  • 近期需要处理很大的数相加,数据的有效位超过16位,而double为最多是16位有效位,且目前的系统中已经没有更大的数据类型来存储...如果是浮点数即存在小数点,则先忽略小数点,把小数点和整数部分和并,正常数值运算...
  • 注意两个整数相除所得结果仍是整数,而非浮点数。   问题描述:已知摄氏温度(℃)与华氏温度(℉)的转换关系是:   编写一个摄氏温度(℃)与华氏温度(℉)进行转换的程序,输入摄氏温度,...
  • 浮点数转换成字符串(c语言

    千次阅读 2013-10-24 09:07:48
    /* * 1.c * * Created on: 2013年10月9日 * Author: lxm2527 */ #include #include char *F2S(double d,char *str) { char str1[40]; int j = 0,k,i;...//浮点数整数部分 while(i > 0) { str1
  • #include "stdafx.h"#include "stdlib.h"char *F2S(double d, char* str){ char str1[40];... //浮点数整数部分 //d = d-(int)d; while(i>0) { str1[j++] = i%10+0; i /= 10; } fo
  • 最近在看一本名为的书。由于我所看过的计算机理论方面的书较少,加上自己...我的确之前对浮点数从没弄明白过),我终于了解了C语言中为什么32位int型数据强制转换到float型会出现精度不能完全保留的现象:------------
  • atof(将字符串转换成浮点型数) 表头文件 #include <stdlib.h> 定义函数 double atof(const char nptr); 函数说明 atof()会扫描参数nptr字符串,跳过前面的空格字符,直到遇上数字或正负符号才开始做转换,而...
  • 谜题2.2 整数浮点数转换请问,下面这个程序的输出是什么?#include #define PR(x) printf(#x " = %.8g/t",(double)x)#define NL putchar(’/n’ )#define PRINT4(x1,x2,x3,x4) PR(x1); PR(x2); PR(x3); PR(x4);...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 471
精华内容 188
关键字:

c语言浮点数转换整数

c语言 订阅