• c语言 整数浮点数 C ++中的所有数字 ( All About Numbers in C++ ) In C++ there are two types of numbers. Ints and floats. There are also variants of these types that hold bigger numbers, or only ...
c语言 整数和浮点数  C ++中的所有数字 (  All About Numbers in C++  )

In C++ there are two types of numbers. Ints and floats. There are also variants of these types that hold bigger numbers, or only unsigned numbers but they are still ints or floats.

在C ++中，有两种类型的数字。 整数和浮点数 。 这些类型也有一些变体，可以容纳更大的数字，或仅保留无符号数字，但它们仍然是整数或浮点数。

An int is a whole number like 47 without a decimal point. You can't have 4.5 babies or loop 32.9 times. You can have $25.76 if you use a float. So when you create your program, you must decide which type to use. 一个整数是一个像47这样的整数，没有小数点。 您不能生育4.5个婴儿，也不能循环32.9次。 如果使用浮点数，则可以有$ 25.76。 因此，在创建程序时，必须确定要使用的类型。
为什么不只使用浮标呢？ (  Why not Just Use Floats?  )

This is what some scripting languages do? Because it's inefficient, floats take up more memory and are generally slower than ints. Also, you cannot easily compare two floats to see if they are equal like you can with ints.

这是某些脚本语言做什么？ 由于浮动效率低下，因此浮动占用更多内存，并且通常比整数慢。 而且，您无法像使用int一样轻松地比较两个浮点数以查看它们是否相等。

To manipulate numbers you have to store them in memory. Because the value can be easily changed, it's called a variable.

要操纵数字，您必须将其存储在内存中。 由于该值可以轻松更改，因此称为变量。
The compiler that reads your program and converts it into machine code needs to know what type it is, i.e. whether it's an int or a float, so before your program uses a variable, you must declare it.

读取程序并将其转换为机器代码的编译器需要知道它是什么类型，即它是int还是float，因此在程序使用变量之前，必须对其进行声明 。

Here's an example.

这是一个例子。
int Counter =0;
float BasicSalary;

You'll notice that the Counter variable is set to 0. This is an optional initialization. It's a very good practice to initialize variables. If you don't initialize and then use them in code without having set an initial value, the variable will start with a random value that may 'break' your code. The value will be whatever was in memory when the program was loaded.

您会注意到Counter变量设置为0。这是可选的初始化。 初始化变量是一个很好的做法。 如果您不进行初始化，然后在未设置初始值的情况下在代码中使用它们，则变量将以可能会“破坏”代码的随机值开头。 该值将是加载程序时内存中的值。
有关Ints的更多信息 (  More about Ints  )

What is the biggest number an int can store?. Well, it depends on the type of CPU but it is generally accepted as 32 bits. Because it can hold almost as many negative values as positive, the range of values is +/- 2-32 to 232 or -2,147,483,648 to +2,147,483,647.

一个int可以存储的最大数量是多少？ 。 好吧，这取决于CPU的类型，但通常被接受为32位。 因为它可以容纳几乎与正数一样多的负值，所以值的范围为+/- 2 -32至2 32或-2,147,483,648至+2,147,483,647。

This is for a signed int, but there is also an unsigned int that holds zero or positive. It has a range of 0 to 4,294,967,295. Just remember - unsigned ints don't need a sign (like + or -1) in front of them because they are always positive or 0.

这是针对有符号的int，但也有一个无符号的 int，它保持零或正数。 它的范围是0到4,294,967,295。 请记住 -无符号整数不需要在它们前面加一个符号(例如+或-1)，因为它们始终为正或0。
短整数 (  Short Ints  )

There is a shorter int type, coincidentally called short int which uses 16 bits (2 bytes). This holds numbers in the range -32768 to +32767. If you use a large umber of ints, you can possibly save memory by using short ints. It will not be any quicker, despite being half the size. 32 Bit CPUs fetch values from memory in blocks of 4 bytes at a time. I.e. 32 bits (Hence the name- 32 Bit CPU!). So fetching 16 bits still requires a 32 bit fetch.

有一个较短的int类型，巧合地称为short int，它使用16位(2个字节)。 该数字范围为-32768至+32767。 如果您使用大量的整数，则可以使用简短的整数来节省内存。 尽管尺寸只有一半，但速度不会更快。 32位CPU一次以4个字节的块的形式从内存中获取值。 即32位(因此命名为32位CPU！)。 因此，获取16位仍需要32位获取。

There is a longer 64 bit called long long in C. Some C++ compilers while not supporting that type directly use an alternate name- e.g. both Borland and Microsoft use _int64. This has a range of -9223372036854775807 to 9223372036854775807 (signed) and 0 to 18446744073709551615 (unsigned).

在C语言中，有一个较长的64位称为long long 。某些不支持该类型的C ++编译器直接使用替代名称-例如Borland和Microsoft都使用_int64 。 其范围是-9223372036854775807至9223372036854775807(带符号)和0至18446744073709551615(无符号)。

As with ints there is an unsigned short int type that has a range of 0..65535.

与int一样，存在无符号short int类型，其范围为0..65535。

Note: Some computer languages refer to 16 bits as a Word.

注意 ：某些计算机语言将16位称为Word。
精密算术 (  Precision Arithmetic  )
双重麻烦 (  Double Trouble  )

There's no long float, but there is a double type that is twice as big as float.

没有长浮点数，但是有一个双精度类型，它是浮点数的两倍。
Float: Occupies 4 bytes. Range 17x10-38 to 1.7x1038  浮点数 ：占用4个字节。 范围17x10 -38至1.7x10 38  Double: Occupies 8 bytes. Range 3.4x10-308 to 3.4308  双精度：占用8个字节。 范围3.4×10 -308到3.4 308
Unless you're doing scientific programming with very large or small numbers, you'll only use doubles for greater precision. Floats are good for 6 digits of accuracy but doubles offer 15.

除非您使用非常大或很小的数字进行科学编程，否则只会使用双精度来提高精度。 浮点数可提供6位数的精度，但双精度浮点数提供15。
精确 (  Precision  )

Consider the number 567.8976523. It is a valid float value. But if we print it out with this code below you can see lack of precision appearing. The number has 10 digits but is being stored in a float variable with only six digits of precision.

考虑数字567.8976523。 这是有效的浮点值。 但是，如果我们在下面的代码中将其打印出来，您会发现缺乏精度。 该数字有10位数字，但存储在float变量中，精度只有6位数字。
#include <iostream>
using namespace std;
int main(int argc, char* argv[])
{
float value = 567.8976523;
cout.precision(8) ;
cout << value << endl;
return 0;
}

See About Input and Output for details on how cout works, and how to use precision. This example sets the output precision to 8 digits. Unfortunately floats can only hold 6 and some compilers will issue a warning about converting a double to a float. When run, this prints out 567.89764

有关cout的工作方式以及使用精度的详细信息，请参见关于输入和输出 。 本示例将输出精度设置为8位数字。 不幸的是，浮点数最多只能容纳6个，并且某些编译器会发出有关将double转换为float的警告。 运行时，将打印出567.89764

If you change the precision to 15, it prints as 567.897644042969. Quite a difference! Now move the decimal point two to the left so the value is 5.678976523 and rerun the program. This time it outputs 5.67897653579712. This is more accurate but still different.

如果将精度更改为15，则打印为567.897644042969。 完全不同！ 现在，将小数点后两位向左移动，以便该值为5.678976523，然后重新运行该程序。 这次输出5.67897653579712。 这更准确，但仍然不同。

If you change the type of value to double and the precision to 10 it will print the value exactly as defined. As a general rule, floats are handy for small, non integer numbers but with more than 6 digits, you have to use doubles.

如果将值的类型更改为double并将精度更改为10，则将完全按照定义打印该值。 通常，浮点数适用于较小的非整数，但位数超过6位，则必须使用双精度。
了解算术运算 (  Learn about Arithmetic Operations  )

Writing computer software wouldn't be much use if you couldn't do addition, subtraction etc. Here's example 2.

如果您不能进行加法，减法等操作，那么编写计算机软件的用处就不会太大。这是示例2。
// ex2numbers.cpp
//
#include <iostream>
using namespace std;
int main()
{
int a=9;
int b= 12;
int total=a+b;
cout << "The total is " << total << endl;
return 0;
}
示例2的说明 (  Explanation of Example 2  )

Three int variables are declared. A and B are assigned values, then total is assigned the sum of A and B.

声明了三个int 变量 。 为A和B分配值，然后为total分配A和B的总和。
在运行此示例之前 (  Before running this example  )

Here's a little tip to save time when running Command Line applications.

这是在运行命令行应用程序时节省时间的一些技巧。

When you run this program from the Command Line, it should output "The number is 22".

当您从命令行运行该程序时，它应输出“数字为22” 。
其他算术运算 (  Other Arithmetic Operations  )

As well as addition, you can do subtraction, multiplication and division. Just use + for addition, - for subtraction, * for multiplication and / for division.

除加法外，您还可以进行减法，乘法和除法。 只需将+用于加法，将-用于减法，将*用于乘法和/除法。

Try changing the above program- use subtraction or multiplication. You can also change ints to floats or doubles.

尝试更改上述程序-使用减法或乘法。 您还可以将int更改为float或double 。

With floats, you have no control over how many decimal points are displayed unless you set the precision as shown earlier.

使用浮点数时，除非您如前所述设置精度，否则您无法控制显示的小数点数。
使用cout指定输出格式 (  Specifying Output Formats with cout  )

When you're outputting numbers, you need to think about these attributes of the numbers.

在输出数字时，需要考虑数字的这些属性。
Width- How much space is needed for the entire number 宽度-整数需要多少空间 Alignment - left or right- numbers tend to be right aligned 对齐-左或右数字趋于右对齐 Number of decimal places 小数位数 Sign or brackets for negative numbers. 负号的符号或方括号。 Thousands Separators. Big numbers look ugly without these. 千位分隔符。 没有这些，大数字看起来很难看。

Now width, alignment, number of decimal places and signs can be set by the cout object and iomanip include file functions.

现在，宽度，对齐方式，小数位数和符号可以由cout对象和iomanip包含文件函数设置。

Thousands separators are a little more complicated. They are set from the locale of a PC. A locale contains information relevant to your country- such as currency symbols and decimal point and thousands separators. In the UK and USA, the number 100.98 uses a decimal point . as the decimal point whereas in some European countries it is a comma so €5,70 means a price of 5 Euros and 70 cents.

千位分隔符要复杂一些。 它们是从PC的语言环境设置的。 语言环境包含与您的国家/地区有关的信息，例如货币符号和小数点以及千位分隔符。 在英国和美国，数字100.98使用小数点。 作为小数点，而在某些欧洲国家中，这是逗号，因此€5,70表示价格为5欧元和70美分。
int main()
{
double a=925678.8750;
cout.setf(ios_base::showpoint|ios_base::right) ;
cout.fill('=') ;
cout.width(20) ;
locale loc("") ;
cout.imbue( loc ) ;
cout.precision(12) ;
cout << "The value is " << a << endl;
//cout.unsetf(ios_base::showpoint) ;
cout << left << "The value is " << a << endl;
for (int i=5;i< 12;i++) {
cout.precision(i) ;
cout << setprecision(i)<< "A= " << a << endl;
}
const moneypunct <char, true> &mpunct = use_facet <moneypunct <char, true > >(loc) ;
cout << loc.name( )<< mpunct.thousands_sep( ) << endl;
return 0;
}

The output from this is

输出是
=======The value is 925,678.875000
The value is 925,678.875000
A= 9.2568e+005
A= 925,679.
A= 925,678.9
A= 925,678.88
A= 925,678.875
A= 925,678.8750
A= 925,678.87500
English_United Kingdom.1252,
关于语言环境和Moneypunct (  About Locale and Moneypunct  )

The example used a locale object from the PC in the line

该示例在该行中使用了来自PC的语言环境对象
locale loc("") ;

The line

线
const moneypunct <char, true> &mpunct = use_facet <moneypunct <char, true > >(loc) ;

creates an object mpunct which is a reference to a moneypunct template class. This has information about the specified locale - in our case, the thousands_sep() method returns the character used for thousands separator.

创建一个对象mpunct ，该对象是对moneypunct模板类的引用。 它具有有关指定语言环境的信息-在我们的例子中， 数千个(sep)方法返回用于千位分隔符的字符。

Without the line

没有线
cout.imbue( loc ) ;

There would be no thousand's separators. Try commenting it out and rerunning the program.

不会有千位分隔符。 尝试将其注释掉并重新运行该程序。

Note There seem to be discrepancies between different compilers as to how cout.imbue behaves. Under Visual C++ 2005 Express Edition, this included separators. But the same code with Microsoft Visual C++ 6.0 did not!

注意不同的编译器之间似乎对cout.imbue的行为存在差异。 在Visual C ++ 2005 Express Edition下，这包括分隔符。 但是与Microsoft Visual C ++ 6.0相同的代码却没有！
小数点 (  Decimal Points  )

The example on the previous page used showpoint to show trailing zeros after the decimal points. It output numbers in what is called standard mode. Other modes include

前一页的示例使用showpoint在小数点后显示尾随零。 它以所谓的标准模式输出数字。 其他模式包括
Fixed Mode - Show numbers like 567.8 固定模式-显示数字如567.8 Scientific Mode - Show numbers like 1.23450e+009 科学模式-显示数字，例如1.23450e + 009

If you use either of these two formatting modes through the cout.setf then precision() sets the number of decimal places after the decimal point (not the overall number of digits) but you lose the thousands formatting. Also trailing zeroes (as were enabled by ios_base::showpoint ) become automatically enabled without needing showpoint.

如果通过cout.setf使用这两种格式化方式中的任何一种，那么precision()会设置小数点后的小数位数(而不是位数的总数)，但是会丢失成千上万种格式。 尾随零(由ios_base :: showpoint启用)也自动启用，而无需showpoint 。
需要注意的事情：整数，浮点数和布尔值 (  Things to Watch out for with ints, floats and bools  )

Take a look at this statement.

看一下这句话。
float f = 122/11;

You'd expect something like a value of 11.0909090909. In fact, the value is 11. Why is this? because the expression on the right-hand side (known as an rvalue) is integer/integer. So it uses integer arithmetic which throws away the fractional part and assigns 11 to f. Changing it to

您可能希望得到的值是11.0909090909。 实际上，值是11。这是为什么？ 因为右侧的表达式 (称为rvalue )是整数/整数。 因此，它使用整数算法，该算法舍弃了小数部分，并为f分配了11。 更改为
float f = 122.0/11

will correct it. It's a very easy gotcha.

将纠正它。 这是一个非常简单的陷阱。
类型Bool和Int (  Types Bool and Int  )

In C, there is no such type as a bool. Expressions in C were based on a zero being false or a non-zero being true. In C++ the type bool can take the values true or false. These values are still equivalent to 0 and 1. Somewhere in the compiler it will have a

在C语言中，没有布尔类型。 C语言中的表达式基于零为假或非零为真。 在C ++中， 布尔类型可以采用true或false值。 这些值仍然等于0和1。在编译器中的某个位置将有一个
const int false=0;
const int true= 1;

Or at least it acts that way! The two lines below are valid without casting so behind the scenes, bools are implicitly converted to ints and can even be incremented or decremented though this is very bad practice.

或者至少它是那样的！ 下面的两行是有效的，无需强制转换，因此在后台将布尔值隐式转换为int，甚至可以递增或递减，尽管这是非常不好的做法。
bool fred=0;
int v = true;

Look at this code

看这段代码
bool bad = true;
if (bad) ...

The if will still do the if as the bad variable is non-zero but it is bad code and should be avoided. Good practice is to use them as they are intended. if (!v) is valid C++ but I prefer the more explicit if (v != 0). That, however, is a matter of taste, not a must-do directive.

if仍将执行if as坏变量，该变量为非零值，但这是坏代码，应避免使用。 优良作法是按预期使用它们。 if(！v)是有效的C ++，但我更倾向于if(v！= 0) 。 但是，这只是一个问题，而不是必须执行的指令。
使用枚举以获得更好的代码 (  Use Enums for Better Code  )

要更深入地了解枚举，请首先阅读本文。
What is an Enum?   什么是枚举？
An enum type provides a way to restrict a variable to one of a fixed set of values.

枚举类型提供了一种将变量限制为一组固定值之一的方法。
enum rainbowcolor {red,orange,green, yellow, blue,indigo,violet};
enum rainbowcolor {red=1000,orange=1005,green=1009, yellow=1010, blue,indigo,violet};

yellow=1010

黄色= 1010
You can assign an enum value to an int as in

您可以像下面这样将枚举值分配给int
int p=red;
rainbowcolor g=1000; // Error!
rainbowcolor g=red;

type safety

类型安全性
it is better for the compiler to catch errors at compile time than the user at runtime

，对于编译器而言，比在运行时用户捕获错误要好于编译时
Even though the two statements are conceptually the same. In fact you'll usually find that these two seemingly identical lines

即使两个语句在概念上是相同的。 实际上，您通常会发现这两行看似相同
int p =1000;
rainbowcolor r = red;

That completes this tutorial. The next tutorial is about expressions and statements.

到此完成了本教程。 下一个教程是关于表达式和语句的。
翻译自: https://www.thoughtco.com/candand-handling-ints-and-floats-958408c语言 整数和浮点数
展开全文
• 学习过程中遇到了一个问题，首先定义了一个一位浮点数a = 1.5，我想把他扩大十倍，之后再缩小十倍 如下图，第一次a返回不了原来的值了 [img=https://img-bbs.csdn.net/upload/202102/18/1613619364_92778.png][/...
• 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语言中浮点数和整数转换
展开全文
• C语言标准C89里规定了3种浮点数，float型、double型和long double型，常见的浮点型长度为float型占4个字节，double型占8个字节，long double型长度要大于等于double型，下面将以float型为例进行介绍，double型和long...
C语言标准C89里规定了3种浮点数，float型、double型和long double型，常见的浮点型长度为float型占4个字节，double型占8个字节，long double型长度要大于等于double型，下面将以float型为例进行介绍，double型和long double型只是比float型位数长，原理是一样的 。float型可以表示的十进制范围是-3.402823466e38~3.402823466e38，而作为同为4个字节的定点数却只能表示-2147483648~2147483647的范围，使用同样的内存空间，浮点数却能比定点数表示大得多的范围，这是不是太神奇了？既然浮点数能表示这么大的范围，那么我们为何不使用浮点数来代替定点数呢？先不说浮点数实现起来比较复杂，有些处理器还专门配置了硬件浮点运算单元用于浮点运算，主要原因是浮点数根本就无法取代定点数，因为精度问题。鱼和熊掌不可兼得，浮点数表示了非常大的范围，但它失去了精度。ANSI/IEEE Std 754-1985标准IEEE 754是最广泛使用的二进制浮点数算术标准，被许多CPU与浮点运算器所采用。IEEE 754规定了多种表示浮点数值的方式，下面介绍32位二进制的float浮点类型。它被分为3个部分，分别是符号位S(sign bit)、指数偏差E(exponent bias)和小数部分F(fraction)，这三部分都是对应二进制码的。浮点表示的一般形式为(科学技术法规则)：R=(S) * (1 + F) * 2e (R：实数       S：正负符号      F：小数部分     e：指数，不同于指数偏差)。符号位S：占1位，0代表浮点数是正数，1代表浮点数是负数。指数偏差E：占8位，范围是0~255，e = E - 127，e为正值表明转换成二进制码后，按科学计数法表达时向左移动了e位， 负值表明向右移动了e位。小数部分F：占23位，实际上是将浮点数转换成二进制码，再按科学计数法表达，将其小数部分存在F上，由于二进制码按科学计数法表达后，只要值不为0，整数部分就必然为1，所以可以省略整数部分。例如，3.75的二进制码为11.11，将该二进制码按科学计数法表达为1.111，则向左移动了1位，即e=1，E=e+127=128，F记录的便是小数部分，实际为111000...000。下面介绍一下小数部分转换为二进制码的方式。类似于整数的形式(如7 = 22 + 21 + 20)，小数部分的转换形式为2-1、2-2、2-3、2-4......，例如0.5 = 2-1，即二进制码为0.1，0.05 = 2-5 + 2-6 + 2-9 + 2-10 + 2-13 + 2-14 +...... (可无限循环)，即二进制码为0.00001100110011......。如果都以16位计，那么7的二进制码为0000000000000111，0.5的二进制码为0.1000000000000000，0.05的二进制码为0.0000110011001100。这是如何换算出来的呢？且看下面的算法便知：换算0.5，乘法结果初始为0.5，所有乘数为2，每次用乘法结果 * 乘数，得到新的乘法结果，结果中的整数部分被提取出来，剩余的小数部分继续参加下一次乘法运算，直到剩余小数部分为0，或者无终点(无限循环)。根据表格中的整数部分可知，二进制为0.1。整数部分乘数乘法结果剩余小数部分0.20.50.5110结束换算0.05，乘法结果初始为0.05，所有乘数为2，每次用乘法结果 * 乘数，得到新的乘法结果，结果中的整数部分被提取出来，剩余的小数部分继续参加下一次乘法运算，直到剩余小数部分为0，或者无终点(无限循环)。根据表格中的整数部分可知，二进制为0.00001100110011......。整数部分乘数乘法结果剩余小数部分0.20.050.05020.10.1020.20.2020.40.4020.80.8121.60.6121.20.2020.40.4020.80.8121.60.611.20.2无限循环例1：float型浮点数125.5转化成32位二进制浮点数。125.5的整数和小数部分的二进制码分别为1111101和0.1，于是125.5的二进制码为1111101.1，按科学技术法写为1.1111011*26，即向左移6位，则e=6，E=e+127=133，133的二进制码为10000101。而1.1111011把整数部分的1去掉后，剩下小数部分为1111011，之后补0至23位，构成F。所以125.5的32位二进制浮点数为：0  10000101  11110110000000000000000例2：float型浮点数0.5转化成32位二进制浮点数。类似的，0.5的二进制码为0.1，按科学技术法写为1.0*2-1，即向右移1位，则e=-1，则E=e+127=126，126的二进制码为01111110。而1.0把整数部分的1去掉后，剩下小数部分为0，之后补0至23位，构成F。所以0.5的32位二进制浮点数为：0  01111110  00000000000000000000000几个特殊的情形E=0，F=0时，表示浮点数0，此时浮点数受S影响，表现出+0和-0两种0，但数值是相等的。比如二进制数0x00000000表示+0，二进制数0x80000000表示-0。E=0，F不等于0时，浮点数为(S) * (F) * 2e，注意e为-126，而不是0-127=-127，而且F是0.xxx格式而不是1.xxx格式，比如0x00000001的浮点数为2-126*2-23=1.4012984643248170709237295832899e-45，而不是20-127*(1+2-23)。E从0变为1，不会产生增加2倍的关系，而是计算公式改变了(恢复正常公式)。E=255，F不等于0时，表示非数值，也就是说是非法数，例如0x7F800001。E=255，F=0时，表示无穷大的数，此时浮点数受S影响，例如0x7F800000表示正无穷大，0xFF800000表示负无穷大。做除法时，如果除以0时，结果将被记作0x7F800000。浮点数的精度从前文中可以看到，1.xxx这类浮点数中，F部分最小的是2-23，对应的十进制数为1.00000011920928955078125，可以精确表示到小数点后23位，但是一些C语言书上却说float型的有效位只有6~7位，这是为什么呢？原因在于二进制小数与十进制小数没有完全一一对应的关系，二进制小数相比十进制小数来说，是离散而不是连续的，我们来看看下面这些数字：二进制小数　　　　十进制小数2-23　　　　　　　1.000000119209289550781252-22　　　　　　　1.00000023841857910156252-21　　　　　　　1.0000004768371582031252-20　　　　　　　1.000000953674316406252-19　　　　　　　1.00000190734863281252-18　　　　　　　1.000003814697265625这里只需要关注F，上面列出了1.xxx这类浮点数中的6个最小的二进制小数，及其对应的十进制数。可以看到使用二进制所能表示的最小小数是1.00000011920928955078125，其次是1.0000002384185791015625，这两个数之间是有间隔的，如果想用二进制小数来表示8位有效数(只算小数部分，小数点前面的1是隐藏的默认值)1.00000002、1.00000003、1.00000004......这些数是无法办到的，而7位有效数1.0000001可以用2-23来表示，1.0000002可以用2-22来表示，1.0000003可以用2-23+2-22来表示。从这个角度来看，float型所能精确表示的位数只有7位，7位之后的数虽然也是精确表示的，但却无法表示任意一个想表示的数值。但还是有一些例外的，比如说7位有效数1.0000006这个数就无法用F表示，这也表明二进制小数对于十进制小数来说相当于是离散的，刚好凑不出1.0000006这个数，从这点来看float型所能精确表示的位数只有6位。因此float型的有效位数是6~7位，但这个说法应该不是非常准确，准确来说应该是6位，C语言的头文件中规定也是6位。对于一个很大的数，例如1234567890，它是由于指数E系数而被放大了的，但它的有效位仍然是F所能表示的6~7位有效数字。1234567890用float表示后为1234567936，只有高7位是有效位，后3位是无效的。int型可以准确的表示1234567890，而float浮点数则只能近似的表示1234567890，精度问题决定了float型无法取代int型。
展开全文
• 整数浮点数与布尔值整数字面量1.可以使用二进制,八进制,十进制,十六进制来表达一个整数字面量.默认为十进制.二进制:0b 八进制:0o 十六进制:0x,字母必须用小写,不能是大写2.如果字面量过长,我们可以使用下划线进行...
整数、浮点数与布尔值整数字面量1.可以使用二进制,八进制,十进制,十六进制来表达一个整数字面量.默认为十进制.二进制:0b 八进制:0o 十六进制:0x,字母必须用小写,不能是大写2.如果字面量过长,我们可以使用下划线进行分割,也可以在数值前面添加一个或多个零,而不影响其大小整数类型1.通过字面量的默认类型就是Int,Int类型表示的整数范围会随不同的处理器与操作系统环境而有所不同;32位:值的范围[-231,231-1],64位:[-263,263-1],当然也可以通过类方法,Int.max,Int.min获取最大值与最小值.2.Int类型是有符号的,Uint是无符号的3.固定位宽的类型,Int8,Uint8,Int16,Uint16,Int32,Uint32,Int64,Uint64,用整数字面量为非Int类型的对象初始化,必须进行类型标注.4.如果整数字面量超出了整形对象所能表示的范围,编译器会报错扩展(与C语言的交互):size_t(在Swift中被定义为 Int)、ptrdiff_t(在Swift中被定义为 Int)、intptr_t(在Swift中被定义为 Int)、uintptr_t(在Swift中被定义为 UInt)。 size_t 在C语言中用于表示sizeof操作符的返回类型。在Swift中， size_t 是带符号的，而在C语言中则是无符号的。 ptrdiff_t 在ptrdiff_t 在C语言中一般用于两个指针对象做减法后可用于保存其差值的整数类型。 intptr_t 与 uintptr_t 在C语言中均可用于存放某一对象的地址，只不过一个是带符号的，一个是无符号的。浮点字面量1.swift支持十进制浮点数,十进制科学计数法,十六进制科学计数法十进制科学计数法:一个十进制整数或十进制浮点数作为底数,后面跟e或E,再紧跟一个十进制整数作为指数,表示:底数 * 10^指数十六进制科学计数法:以0x为前缀,后面跟十六进制浮点数,后面再跟p或P,再紧跟一个十进制整数,表示:十六进制浮点数 * 2^指数//这里类型推导为Double//相当于250000 2.5 * 10^5let a = 2.5e5//相当于0x2.132p0 * 2^3//注意:p0不可以省略,编译器会报错//Hexadecimal floating point literal must end with an exponentlet c = 0x2.132p3//0.0625 0.01171875 0.00048828125//0x2.132 相当于 2 + 1/16^1 + 3/16^2 + 2/16^3let d = 0x2.132p0浮点数类型1.浮点类型:32位(单精度浮点类型)的Float,64位(双精度浮点类型)的Double.浮点数字面量默认为Doule类型,通过字面量声明Float必须使用类型标注2.Float32(单精度),Float64(双精度型),Float80(扩展双精度浮点类型,x86,ARM不支持)布尔类型Swift原生支持布尔类型(没有C,Objective-C,C++中的非零即真,零即为假,导致布尔类型被整形模糊化了),用Bool表示//'Int' is not convertible to 'Bool'if 1 {print("true")}else{print("false")}2.字面量,关键字true(真),false(假);布尔类型一般用于比较操作表达式,作为条件语句,循环语句的判别,函数返回类型.数值类型的相互转换1.整数,浮点数,布尔类型均为结构体类型,使得无法隐式转换,即使是低精度转高精度也不可以;而且swift的结构体不具有继承的特征,只能通过各个类型自身的构造方法做显示转换.2.高精度转低精度,需要确保高精度的范围在目标精度的范围之内,否则将转换失败,因此转换后的类型一般为可选型,转换失败即为nil3.swift每种数值类型都提供一个供NSNumber类型作为输入参数的构造方法,用于转换.整数和浮点数可用的操作符1.算数操作运算符:加法(+)、减法(-)、乘法()、除法(/)以及取相反数操作(-)和取正数操作符(+)2.求模运算符(%):只能用于整形,浮点数不能作为求模运算的操作数3.比较操作符:大于(>)、大于等于(>=)、小于( 4.按位操作(整数类型):按位与(&),按位或(|),按位异或(^),按位取反(~)5.移位操作(整数类型):左移(<>),如果右移操作的左操作数是一个带符号整数，那么使用的是扩充符号位的算术右移；如果左操作数是一个无符号整数，那么使用的是高位直接用零填充的逻辑右移。此外，移位操作的右操作数必须是一个非负整数。C语言中关系操作符(即Swift中的比较操作符)的优先级比按位操作符要高，这是因为C语言中没有显式的布尔类型，一个关系操作符的结果也是一个整型值。Swift编程语言中，移位操作符、按位操作符的优先级都比条件操作符要高。6.布尔类型对象可以使用逻辑操作符：并且(&&)、或者(||)以及非(!)。如果一个逻辑表达式中存在多个逻辑操作符，那么其操作优先级为：! > && > ||。对于并且(&&)操作，如果其左操作数表达式的值为假，那么直接返回结果 false，而不会执行其右操作数的表达式。对于或者(||)操作，如果其左操作表达式的值为真，那么也不会再去计算右操作数表达式，而直接返回 true7.赋值操作符:赋值操作符(=)以及与赋值操作相关的 +=、-=、=、/= 等操作符与C语言的返回类型有所不同！C语言中，这些操作符表达式的返回类型为这些操作符的左操作数类型；而在Swift中则是返回 Void 类型8.圆括号操作符:优先级要大于任一算术逻辑操作符溢出计算操作对一个整数做一个算术运算发生了溢出,那么程序会在运行时抛出异常.不引发异常可以使用溢出操作符:可溢出的加法(&+),可溢出的减法(&-),可溢出的乘法:(&*)溢出的结果计算方法(同C语言):高位舍去,只保留能容下当前整数对象的地位比特位,然后以补码的形式确定数值
展开全文
• 本文主要介绍通过C语言来获得浮点数在内存中的实际存储方式。  浮点数在内存中是按照IEEE754标准进行存储的，本文以单精度浮点型为例，也就是C语言中的float型，双精度存储原理与单精度的类似，只是位数长度不同...
• 文章目录浮点数C语言规定:总结:浮点数的输出常用的库函数应用技巧科学记数法 浮点数 浮点数也称小数或实数, C语言中采用float 和double关键字来定义小数, float 称为单精度浮点型, double称为双精度浮点型,long ...
• 浮点数转换float比int表示的范围比int大得多，float类型不能作为精确数据来的。float的运算速度比int运算速度慢小结：浮点小数的内存表示和整数的内存表示不一样 浮点类型可以表示的范围更...
• 浮点数在内存中的储存方式为：符号位 指数位 尾数 float和double类型的数据在计算机内部的表实方法是一样的，但是由于所占的存贮空间的不同，其分别能表示的数值范围和精度不同。 类型 f符号位 指数 ...
• c语言可移植类型：stdint.h 和 inttypes.h #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;inttypes.h&amp;gt; int main(int argc, char const *argv[]) { int32_t me32; scanf(&quot;%&...
• 比如浮点数转化成整数，就有以下四种情况。  1.简单粗暴，直接转化 float f = 1.5; int a; a = (int)f; NSLog("a = %d",a);12341234 输出结果是1。（int）是强制类型转化，丢弃浮点数的小数部分。 2.高斯函数
• 剖析Intel IA32架构下C语言及CPU浮点数机制   前言    这两天翻看一本C语言书的时候，发现上面有一段这样写到   例：将同一实型数分别赋值给单精度实型和双精度实型，然后打印输出。    #include ...
• 本篇博客将阐述、讨论的内容：●...●unsigned int(无符号整型)以16位系统为例，unsigned int能存储的数据范围是0~65535(需要注意整数是以补码形式存放)。其进行的是模数计算，也就是所谓的二进制相加减，计算方...
• 这里以C语言浮点数为例，在IEEE浮点标准下，整数转换浮点数的过程做一些直观的分析和具体的实现，IEEE浮点数的标准细节详见（http://en.wikipedia.org/wiki/IEEE_754-2008）。 在C语言中，使用float和double...
• 在一些应用中，需要将整数、浮点数转换成字符串，用于显示或者...1.整数转换成字符串 //整数转换成字符串,参数：生成的数组str,待转换的整数Num,整数长度为len void Num2Str(char str[],int Num,unsigned char len
• 浮点数的计算机表示符合IEEE 754标准，但是要注意，E在表示时存在偏置量。浮点数表示机制考虑较全面，分为三种浮点数：规格化浮点数、非规格化浮点数、一些特殊值。
• 你说“我希望打印的结果是浮点数而不是字符串”和“结果返回一个负幂浮点数，我希望保留十进制格式作为字符串”。但是你不能这样做，因为你无法控制afloat的内部表示：它们都是以科学记数法的二进制形式存储的。有关...
• ）的一个转换，这将在下面介绍浮点数格式的小节中详细描述。 上面的指令执行后，不会进行弹栈操作，即 st(0) 的值不会丢失，而下面就是同种指令 的弹栈版本： fstps 0x12345678 这条指令的功能几乎于上面一条指令...
• atof（将字符串转换成浮点型数） 表头文件 #include <stdlib.h> 定义函数 double atof(const char nptr); 函数说明 atof()会扫描参数nptr字符串，跳过前面的空格字符，直到遇上数字或正负符号才开始做转换，而...

...

c语言 订阅