blocks|key|1510075|text|void+f(unsigned+int+x)
{
//
}

void+f(int+x)
{
//
}
...
f(3);+//+f(int+x)
f(3u);+//+f(unsigned+int+x)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1510076|它只是C%2B%2B中的另一个工具；如果您不需要它，就不要使用它！|unstyled|1510077|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>void f(unsigned int x)
{
//
}

void f(int x)
{
//
}
...
f(3); // f(int x)
f(3u); // f(unsigned int x)
</code></pre>

It is just another tool in C++; if you don't need it don't use it!

blocks|key|210093|text|在您提供的示例中，它是不需要的。但后缀通常用在表达式中，以防止精度损失。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|210094|unsigned+long+x+=+5UL+*+...|code-block|syntax|javascript|210095|如果您没有使用UL后缀，您可能会得到不同的结果，例如，如果您的系统具有16位整数和32位长整型。|210096|这里是另一个例子，灵感来自Richard+Corden的评论：|210097|unsigned+long+x+=+1UL+<<+17;|210098|同样，如果您有16位或32位整数，如果您去掉后缀，您将得到不同的结果。|210099|同样类型的问题也适用于32位与64位整数，以及在表达式中混合long和long+long。|210100|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

In the examples you provide it isn't needed. But suffixes are often used in expressions to prevent loss of precision. For example:

<pre><code>unsigned long x = 5UL * ...
</code></pre>

You may get a different answer if you left off the UL suffix, say if your system had 16-bit ints and 32-bit longs.

Here is another example inspired by Richard Corden's comments:

<pre><code>unsigned long x = 1UL &lt;&lt; 17;
</code></pre>

Again, you'd get a different answer if you had 16 or 32-bit integers if you left the suffix off.

The same type of problem will apply with 32 vs 64-bit ints and mixing long and long long in expressions.

blocks|key|1510087|text|我想有些编译器可能会发出警告。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1510088|作者这样做可能是为了确保代码没有警告？|1510089|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Some compiler may emit a warning I suppose. 
The author could be doing this to make sure the code has no warnings?

blocks|key|4509608|text|对不起，我知道这是一个相当古老的问题，但我在c%2B%2B11代码中经常使用这个问题……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4509609|ul、d、f对于将auto变量初始化为您想要的类型都很有用，例如|offset|length|style|CODE|4509610|auto+my_u_long+=+0ul;
auto+my_float++=+0f;
auto+my_double+=+0d;|code-block|syntax|javascript|4509611|查看cpp对数字文字的引用：http://www.cplusplus.com/doc/tutorial/constants/|4509612|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cplusplus.com/doc/tutorial/constants/^0|0|0|2|3|1|5|1|9|4|0|0|E|1C|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]|$D|14|E|15|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|17|8|@]|9|@$D|18|E|19|1|1A]]|A|$]]|$1|O|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Sorry, I realize this is a rather old question, but I use this a lot in c++11 code...

<code>ul</code>, <code>d</code>, <code>f</code> are all useful for initialising <code>auto</code> variables to your intended type, e.g.

<pre><code>auto my_u_long = 0ul;
auto my_float = 0f;
auto my_double = 0d;
</code></pre>

Checkout the cpp reference on numeric literals: <a href="http://www.cplusplus.com/doc/tutorial/constants/" rel="nofollow">http://www.cplusplus.com/doc/tutorial/constants/</a>

blocks|key|1511712|text|你通常不需要它，任何可以容忍的编辑器都会有足够的帮助来让事情变得清晰。但是，我在C#中使用它的地方是(您将在C%2B%2B中看到以下内容)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1511713|1511714|调用泛型方法(C%2B%2B中的模板)，其中参数类型是隐含的，您希望确保并调用具有unsigned+long类型的方法。这种情况经常发生，包括最近的这一次：|unordered-list-item|offset|length|style|CODE|1511715|1511716|Tuple<ulong,+ulong>+=+Tuple.Create(someUlongVariable,+0UL);|1511717|如果没有UL，它将返回Tuple<ulong,+int>，并且不会compile.|1511718|Implicit变量声明，在C#中使用var关键字，或者在auto中使用C%2B%2B关键字。这对我来说不太常见，因为我只使用var来缩短非常长的声明，而ulong正好相反。|1511719|1511720|entityMap^0|0|0|11|D|0|0|0|1N|0|4|2|B|H|0|J|3|T|4|1N|3|21|5|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|V|8|@$F|W|G|X|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|Z|8|@$F|10|G|11|H|I]]|9|@]|A|$]]|$1|M|3|N|5|6|7|12|8|@$F|13|G|14|H|I]|$F|15|G|16|H|I]]|9|@]|A|$]]|$1|O|3|P|5|E|7|17|8|@$F|18|G|19|H|I]|$F|1A|G|1B|H|I]|$F|1C|G|1D|H|I]|$F|1E|G|1F|H|I]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|S|$]]

You don't normally need it, and any tolerable editor will have enough assistance to keep things straight. However, the places I use it in C# are (and you'll see these in C++):

<ul>
<li>Calling a generic method (template in C++), where the parameter types are implied and you want to make sure and call the one with an <code>unsigned long</code> type. This happens reasonably often, including this one recently: 
<code>Tuple&lt;ulong, ulong&gt; = Tuple.Create(someUlongVariable, 0UL);</code> 
where without the <code>UL</code> it returns <code>Tuple&lt;ulong, int&gt;</code> and won't compile.</li>
<li>Implicit variable declarations using the <code>var</code> keyword in C# or the <code>auto</code> keyword coming to C++. This is less common for me because I only use <code>var</code> to shorten very long declarations, and <code>ulong</code> is the opposite.</li>
</ul>

blocks|key|4509563|text|当你觉得有义务写下常量的类型时(即使不是绝对必要的)，你要确保：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4509564|4509565|你总是考虑编译器如何将这个常量转换成位|ordered-list-item|4509566|读过你的代码的人总会知道你认为这个常量是什么样子的，你也会考虑到它(即使是你，当你重新扫描代码时)|4509567|你不会花时间去考虑你是需要写'U'/'UL‘还是不需要写它|4509568|4509569|此外，像MISRA这样的几个软件开发标准要求您无论如何都要提到常量的类型(如果没有符号，至少要写“U”)。|4509570|换句话说，一些人认为编写常量类型是一种很好的做法，因为在最坏的情况下，您可以忽略它，最好的情况是避免bug，避免不同的编译器以不同的方式处理您的代码并提高代码的可读性。|4509571|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|R|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|T|8|@]|9|@]|A|$]]|$1|H|3|I|5|E|7|U|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

When you feel obligated to write down the type of constant (even when not absolutely necessary) you make sure:

<ol>
<li>That you always consider how the compiler will translate this constant into bits</li>
<li>Who ever reads your code will always know how you thought the constant looks like and that you taken it into consideration (even you, when you rescan the code)</li>
<li>You don't spend time if thoughts whether you need to write the 'U'/'UL' or don't need to write it</li>
</ol>

also, several software development standards such as MISRA require you to mention the type of constant no matter what (at least write 'U' if unsigned)

in other words it is believed by some as good practice to write the type of constant because at the worst case you just ignore it and at the best you avoid bugs, avoid a chance different compilers will address your code differently and improve code readability

<pre><code>ulong foo = 0;
ulong bar = 0UL;//this seems redundant and unnecessary. but I see it a lot.
</code></pre>

I also see this in referencing the first element of arrays a good amount

<pre><code>blah = arr[0UL];//this seems silly since I don't expect the compiler to magically
 //turn '0' into a signed value
</code></pre>

Can someone provide some insight to why I need 'UL' throughout to specify specifically that this is an unsigned long?

Why or why not should I use 'UL' to specify unsigned long?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

ulong foo = 0;ulong bar = 0UL;//this seems redundant and unnecessary. but I see it a lot.我在引用数组的第一个元素时也看到了这一点blah = arr[0UL];//this seems silly since I don't expect the compiler to magically          

问为什么我应该使用“UL”来指定unsigned long？
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我应该使用“UL”来指定unsigned long？EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么我应该使用“UL”来指定unsigned long？
EN