# 什么0LL或0x0UL是什么意思？ [英] What do 0LL or 0x0UL mean?

### 问题描述

I am reading the Google Go tutorial and saw this in the constants section:

There are no constants like 0LL or 0x0UL

I tried to do a Google search but all that comes up are instances where people are using these constants but no explanation as to what they mean. 0x is supposed to start a hexadecimal literal but these are not characters that are possible in a hexadecimal number.

### 推荐答案

These are constants in C and C++. The suffix `LL` means the constant is of type `long long`, and `UL` means `unsigned long`.

In general, each `L` or `l` represents a `long` and each `U` or `u` represents an `unsigned`. So, e.g.

``````1uLL
``````

``````1.0f    // of type 'float'
1.0     // of type 'double'
1.0L    // of type 'long double'
``````

and strings and characters, but they are prefixes:

`````` 'A'   // of type 'char'
L'A'   // of type 'wchar_t'
u'A'   // of type 'char16_t' (C++0x only)
U'A'   // of type 'char32_t' (C++0x only)
``````

In C and C++ the integer constants are evaluated using their original type, which can cause bugs due to integer overflow:

``````long long nanosec_wrong = 1000000000 * 600;
// ^ you'll get '-1295421440' since the constants are of type 'int'
//   which is usually only 32-bit long, not big enough to hold the result.

long long nanosec_correct = 1000000000LL * 600
// ^ you'll correctly get '600000000000' with this

int secs = 600;
long long nanosec_2 = 1000000000LL * secs;
// ^ use the '1000000000LL' to ensure the multiplication is done as 'long long's.
``````

In Google Go, all integers are evaluated as big integers (no truncation happens),

``````    var nanosec_correct int64 = 1000000000 * 600
``````

``````    var b int32 = 600
var a int64 = 1000000000 * b
// ^ cannot use 1000000000 * b (type int32) as type int64 in assignment
``````

so the suffixes are not necessary.

##### 热门工具
###### 登录 关闭 