blocks|key|854732|text|双精度数是浮点数。您可能应该使用long+long。我不知道哪个别名是首选的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|854733|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Doubles are floating-point.
You should use long long, probably. I don't know which alias is the preferred one.

blocks|key|1290840|text|使用long+long，如果可能的话，添加一个编译时断言，说明这个类型足够宽(像sizeof(+long+long+)+>=+8一样)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1290841|double用于浮点运算，而不是整数运算。|1290842|entityMap^0|2|9|14|O|0|0|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

Use <code>long long</code> and if possible add a compile-time assertion that this type is wide enough (smth like <code>sizeof( long long ) &gt;= 8</code>).

<code>double</code> is for floating-point, not integer.

blocks|key|4072359|text|如果你不需要负数，unsigned+long+long听起来就像你能得到的大多数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4072360|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

if you don't need negative numbers, unsigned long long sounds like most you can get.

blocks|key|4072403|text|在C%2B%2B中没有可移植的方法来实现这一点，因为该语言没有指定整数类型的大小(除了sizeof+char是1)。您需要查阅编译器文档。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4072404|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

There is no portable way of doing this in C++, as the language does not specify the size of integer types (except sizeof char is 1). You need to consult your compiler documentation.

blocks|key|854860|text|尝试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|854861|http://gmplib.org/大号。|offset|length|854862|http://mattmccutchen.net/bigint/大整数。|854863|我都没用过，但我在Java里用过类似的东西。|854864|entityMap|0|LINK|mutability|MUTABLE|url|http://gmplib.org/|1|http://mattmccutchen.net/bigint/^0|0|0|I|0|0|0|W|1|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@$D|V|E|W|1|X]]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@$D|Z|E|10|1|11]]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]|R|$5|M|N|O|A|$P|S]]]]

Try:

<a href="http://gmplib.org/" rel="noreferrer">http://gmplib.org/</a> big num.

<a href="http://mattmccutchen.net/bigint/" rel="noreferrer">http://mattmccutchen.net/bigint/</a> big int.

I've used neither, but I've used similiar things in Java.

blocks|key|1292497|text|我使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1292498|uint64_t|code-block|syntax|javascript|1292499|但这不是标准的。|1292500|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I use 

<pre><code>uint64_t
</code></pre>

But it's not standard.

blocks|key|4917762|text|如果你的编译器没有long+long，你可以自己用一个包含两个long的结构来实现它们，但是你需要注意进位等，当然你也可以使用像GMP这样的多精度算法|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4917763|entityMap|0|LINK|mutability|MUTABLE|url|http://gmplib.org/^0|1S|3|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

If your compiler does not have long long you can implement them yourself with a structure containing two long but you will need to be caurseful with carry etc. You could of course look for a Multiple Precision Arithmetic like <a href="http://gmplib.org/" rel="nofollow noreferrer">GMP</a>

blocks|key|4917810|text|这两种建议都不好，因为long+long不是标准的C%2B%2B数据类型，而double是浮点类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4917811|因为我的程序必须是可移植的，所以我要#定义我自己的类型，它适合我使用的所有编译器(visual+studio和gcc)：|4917812|#ifdef+WIN32
++#define+unsigned_long_long+unsigned+__int64
++#define+long_long+__int64
#else+//+gcc.+Might+not+work+on+other+compilers!
++#define+unsigned_long_long+unsigned+long+long
++#define+long_long+long+long
#endif|code-block|syntax|javascript|4917813|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Both proposals aren't good because long long is not a standard C++ data type, and double is a floating-point.

Since my program has to be portable, I am going to #define my own types, that suit all the compilers that I use (visual studio and gcc) :

<pre><code>#ifdef WIN32
 #define unsigned_long_long unsigned __int64
 #define long_long __int64
#else // gcc. Might not work on other compilers!
 #define unsigned_long_long unsigned long long
 #define long_long long long
#endif
</code></pre>

blocks|key|4917832|text|试试TTMath。您所需要做的就是包含一个标头，然后声明一个bignum类型，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4917833|typedef+ttmath::UInt<100>+BigInt;|code-block|syntax|javascript|4917834|它创建了一个可以容纳0到2%5E+(32*100)-1之间的无符号整数的类型。然后只要你想用int的地方就用BigInt。|style|CODE|4917835|当然，您可以为模板参数选择任意大小。100可能是过度杀伤力;-)|4917836|我刚刚意识到，该库只能在x86和x64上运行，但在这些处理器上是跨平台的。|4917837|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ttmath.org/ttmath^0|2|6|0|0|0|18|3|1G|6|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@$A|14|B|15|K|L]|$A|16|B|17|K|L]]|9|@]|C|$]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|19|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

Try <a href="http://www.ttmath.org/ttmath" rel="nofollow noreferrer">TTMath</a>. All you need to do is include a single header and then declare a bignum type such as:

<pre><code>typedef ttmath::UInt&lt;100&gt; BigInt;
</code></pre>

which creates a type that can hold unsigned integers between 0 and 2 ^ (32*100)-1. 
Then just use <code>BigInt</code> wherever you would use <code>int</code>.

Of course you can choose whatever size you like for the template parameter. 100 might be overkill ;-)

Just realised, the lib only works on x86 and x64, but is OS cross-platform on those processors.

blocks|key|1290971|text|不要使用双精度，因为：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1290972|cout.setf(ios::fixed);
cout+<<+LONG_LONG_MAX+<<+endl;
cout+<<+double(LONG_LONG_MAX)+<<+endl;

cout+<<+LONG_LONG_MAX-100+<<+endl;
cout+<<+double(LONG_LONG_MAX-100)+<<+endl;|code-block|syntax|javascript|1290973|输出：|1290974|9223372036854775807
9223372036854775808.000000
9223372036854775707
9223372036854775808.000000|1290975|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Don't use double, because:

<pre><code>cout.setf(ios::fixed);
cout &lt;&lt; LONG_LONG_MAX &lt;&lt; endl;
cout &lt;&lt; double(LONG_LONG_MAX) &lt;&lt; endl;

cout &lt;&lt; LONG_LONG_MAX-100 &lt;&lt; endl;
cout &lt;&lt; double(LONG_LONG_MAX-100) &lt;&lt; endl;
</code></pre>

Output:

<pre><code>9223372036854775807
9223372036854775808.000000
9223372036854775707
9223372036854775808.000000
</code></pre>

blocks|key|1292604|text|许多当前的C/C%2B%2B编译器都有stdint.h或inttyes.h头文件。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1292605|int_fast64_t或int64_t可能是一种选择(我认为这是最便携的)。|style|CODE|1292606|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Stdint.h^0|F|8|0|0|0|C|D|7|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@$A|U|B|V|F|G]|$A|W|B|X|F|G]]|9|@]|C|$]]|$1|H|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

A lot of current C/C++ compilers have either <a href="http://en.wikipedia.org/wiki/Stdint.h" rel="nofollow noreferrer">stdint.h</a> or inttypes.h header.

<code>int_fast64_t</code> or <code>int64_t</code> may be an option (IMHO the most portable).

blocks|key|855171|text|我将假设您的数字将适合64位。如果不是，那么您需要一个arbitrary-precision+arithmetic+library，比如GMP。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|855172|从理论上讲，在C%2B%2B中没有简单、可移植的方法来完成64位数学运算。实际上，大多数C%2B%2B编译器还支持“老式”的C标头，C99有一个很好的标头，叫做stdint.h。|855173|所以首先要做的是：|855174|#include+<stdint.h>|code-block|syntax|javascript|855175|然后使用类型int64_t+(有符号)和uint64_t+(无符号)。|style|CODE|855176|编辑添加：在我写完这个答案之后，C%2B%2B11添加了+header，它通常*定义std::int64_t和std::uint64_t，所以如果你有一个现代的编译器，最好使用它们。|BOLD|855177|(*理论上，系统可能根本不支持64位类型。但在实践中，它将在您可能遇到的任何系统上实现)。|855178|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic|1|http://gmplib.org/|2|http://en.wikipedia.org/wiki/Stdint.h|3^0|R|12|0|1W|3|1|0|20|8|2|0|0|0|6|7|K|8|0|0|5|O|7|3|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@$A|19|B|1A|1|1B]|$A|1C|B|1D|1|1E]]|C|$]]|$1|D|3|E|5|6|7|1F|8|@]|9|@$A|1G|B|1H|1|1I]]|C|$]]|$1|F|3|G|5|6|7|1J|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1K|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1L|8|@$A|1M|B|1N|O|P]|$A|1O|B|1P|O|P]]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1Q|8|@$A|1R|B|1S|O|S]]|9|@$A|1T|B|1U|1|1V]]|C|$]]|$1|T|3|U|5|6|7|1W|8|@]|9|@]|C|$]]|$1|V|3|-4|5|6|7|1X|8|@]|9|@]|C|$]]]|W|$X|$5|Y|Z|10|C|$11|12]]|13|$5|Y|Z|10|C|$11|14]]|15|$5|Y|Z|10|C|$11|16]]|17|$5|Y|Z|10|C|$11|16]]]]

I'm going to assume your numbers will fit in 64 bits. If not, then you need an <a href="http://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic" rel="nofollow noreferrer">arbitrary-precision arithmetic library</a> such as <a href="http://gmplib.org/" rel="nofollow noreferrer">GMP</a>.

In theory, there's no easy, portable way to do 64-bit maths in C++. In practise, most C++ compilers also support the "old fashioned" C headers, and C99 has a nice header called <a href="http://en.wikipedia.org/wiki/Stdint.h" rel="nofollow noreferrer">stdint.h</a>.

So first do:

<pre><code>#include &lt;stdint.h&gt;
</code></pre>

Then use types <code>int64_t</code> (signed) and <code>uint64_t</code> (unsigned).

EDIT TO ADD: After I wrote this answer, C++11 added the <a href="http://en.wikipedia.org/wiki/Stdint.h" rel="nofollow noreferrer">&lt;cstdint&gt; header</a> which normally* defines std::int64_t and std::uint64_t , so if you have a modern compiler it's best to use those.

(* In theory the system might not support a 64-bit type at all. But in practise it will, on any system you're likely to come across).

blocks|key|4918039|text|你的程序应该有多好的可移植性？TR1有cstdint和stdint.h，所以大多数最新的编译器都支持它。如果不支持cstdint，还可以使用Boost+cstdint.hpp。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4918040|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

How portable should your program be? TR1 has cstdint and stdint.h so it's likely supported by most up-to-date compilers. Then there is Boost cstdint.hpp that you should be able to use if cstdint is not supported.

blocks|key|4072765|text|只是出于好奇--如果你愿意，我认为编写你自己的代码不会太难。我的意思是，所有这些数据类型都有预定义的结构，当然，例如，您可以使用使用指数的double结构，并执行以下操作：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4072766|为了容纳一个非常大的数字，超出双精度的范围，创建一个对象，它有两个部分-数字和10的幂，|4072767|所以，如果你想存储像这样的东西|4072768|1.1230123123+x+10%5E(1000000000000000000000000000000000000000000000)，这不是双精度型所支持的，您可以使用1.123+...部分存储在一个双精度数中，然后将十的幂作为单独的双精度/整型/浮点型(任何合适的)，然后从那里取它。当然，这可能不是最好的方式-而且你可能需要编写很多除法、减法等功能的代码，但它肯定是可移植的，因为你将使用定义的普通数据类型。它的可用性将取决于您试图实现什么，以及您是否计划在单个项目之外使用它，但我认为如果这些类型的数字是绝对需要的，那么它是一种可靠的方法|4072769|entityMap^0|1X|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|S|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|M|$]]

Just out of curiosity - I don't think it would be too hard to code your own if you wanted to. I mean, all of these data types have predefined structures, of course, but you could, for example, use the <code>double</code> structure which uses exponents, and do something like this:

to hold a VERY large number, beyond the scale of a double, create an object that has two parts to it - the number and the power to ten,

so, if you wanted to store something like

1.1230123123 x 10^(100000000000000000000000000000000000), which isn't supported by a double, you could have the 1.123 ... part stored in a double, and then the power of ten as a seperate double/int/float (whatever suits), and then take it from there. Of course, this may not be the best way - and you would probably have to code in a lot of functionality for division, subtraction etc, but it would definitely by portable, as you would be using the normal data types defined. The useability of this would depend on what you are trying to achieve and whether or not you plan to use this beyond a single project, but I think it is a liable way to do it if those sorts of numbers are an absolute requirement

I have an integer variable, that can get a value larger than 4294967295.

What type should I use for it (long long, or double, or something else)?

What type to use for integers larger than 2^32 in C++?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个整数变量，它可以得到一个大于4294967295的值。我应该为它使用什么类型(long long、double或其他类型)？

问在C++中，对大于2^32的整数使用什么类型？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中，对大于2^32的整数使用什么类型？EN