c语言整数和浮点数_C ++处理整数和浮点数

╰半橙微兮° 2022-12-07 12:10 291阅读 0赞

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 ++中，有两种类型的数字。 [整数][Ints]和[浮点数][floats] 。 这些类型也有一些变体，可以容纳更大的数字，或仅保留[无符号][unsigned]数字，但它们仍然是整数或浮点数。

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.

要操纵数字，您必须将其存储在内存中。 由于该值可以轻松更改，因此称为变量。

*  Read more about variables in [What is a Variable?][What is a Variable]
    
    在[什么是][What is a Variable]变量中阅读有关变量的更多信息[。][What is 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.

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

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][compiler] 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][compiler]的类型，但通常被接受为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，但也有一个[无符号的][unsigned] 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.

没有长浮点数，但是有一个[双][double]精度类型，它是浮点数的两倍。

*  **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的工作方式以及使用精度的详细信息，请参见[关于输入和输出][About Input and Output] 。 本示例将输出精度设置为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 [变量][variables] 。 为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][double].

尝试更改上述程序-使用减法或乘法。 您还可以将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的语言环境[对象][object]

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][declare]) 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。这是为什么？ 因为右侧的[表达式][expression] (称为[rvalue][declare] )是整数/整数。 因此，它使用整数算法，该算法舍弃了小数部分，并为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语言中，没有[布尔][bool]类型。 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;
    bad++
    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 **)** ##

For a more in depth look at enums, read this article first.

要更深入地了解枚举，请首先阅读本文。

*  [What is an Enum? ][What is an Enum_]
    
    [什么是枚举？][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.][]

到此完成了本教程。 下一个教程是[关于表达式和语句的。][about expressions and statements.]

> 翻译自: [https://www.thoughtco.com/candand-handling-ints-and-floats-958408][https_www.thoughtco.com_candand-handling-ints-and-floats-958408]

c语言 整数和浮点数

[Ints]: https://www.thoughtco.com/definition-of-int-958297
[floats]: https://www.thoughtco.com/definition-of-float-958293
[unsigned]: https://www.thoughtco.com/definition-of-unsigned-958174
[What is a Variable]: https://www.thoughtco.com/what-is-a-variable-958334
[compiler]: https://www.thoughtco.com/definition-of-compiler-958198
[declare]: https://www.thoughtco.com/parameter-2034268
[double]: https://www.thoughtco.com/definition-of-double-958065
[About Input and Output]: https://www.thoughtco.com/learn-about-input-and-output-958405
[variables]: https://www.thoughtco.com/definition-of-variable-958320
[object]: https://www.thoughtco.com/object-2034254
[expression]: https://www.thoughtco.com/statement-2034294
[bool]: https://www.thoughtco.com/definition-of-bool-958287
[What is an Enum_]: https://www.thoughtco.com/what-is-an-enum-958326
[about expressions and statements.]: https://www.thoughtco.com/expression-2034097
[https_www.thoughtco.com_candand-handling-ints-and-floats-958408]: https://www.thoughtco.com/candand-handling-ints-and-floats-958408