数値、ブール値、およびポインターのリテラルNumeric, boolean and pointer literals

リテラルとは、値を直接に表すプログラム要素です。A literal is a program element that directly represents a value. ここでは、整数型、浮動小数点型、ブール値型、およびポインター型のリテラルについて説明します。This article covers literals of type integer, floating-point, boolean and pointer. 文字列リテラルと文字リテラルの詳細については、「文字列C++リテラルと文字リテラル ()」を参照してください。For information about string and character literals, see String and Character Literals (C++). また、これらのカテゴリのいずれかに基づいて独自のリテラルを定義することもできます。詳細については、「ユーザー定義C++リテラル () 」を参照してください。You can also define your own literals based on any of these categories; for more information see User-Defined Literals (C++)

を確認しています。. リテラルは多様なコンテキストで使用できますが、最も一般的な用途は、名前付きの変数を初期化することと、関数に引数を渡すことです。You can use literals in many contexts, but most commonly to initialize named variables and to pass arguments to functions:

const int answer = 42; // integer literal
double d = sin(108.87);     //floating point literal passed to sin function
bool b = true;              // boolean literal
MyClass* mc = nullptr;      // pointer literal

リテラルの解釈方法やリテラルに与える特定の型を、コンパイラに指示することが重要な場合があります。Sometimes it's important to tell the compiler how to interpret a literal, or what specific type to give to it. リテラルにプレフィックスまたはサフィックスを追加することによってこれを行います。You do this by appending prefixes or suffixes to the literal. たとえば、プレフィックス 0x は、それに続く数値を 16 進数値として解釈するようコンパイラに指示します (0x35 など)。For example, the prefix 0x tells the compiler to interpret the number that follows it as a hexadecimal value, for example 0x35. U) サフィックスは、5894345ULL のように、値をunsigned long long型として扱うようにコンパイラに指示します。The ULL suffix tells the compiler to treat the value as an unsigned long long type, as in 5894345ULL. 各リテラル型のプレフィックスおよびサフィックスの完全な一覧については、次のセクションを参照してください。See the following sections for the complete list of prefixes and suffixes for each literal type.

整数リテラルInteger literals

整数リテラルは数字で始まり、小数部や指数はありません。Integer literals begin with a digit and have no fractional parts or exponents. 整数リテラルには、10 進数、8 進数、または 16 進数形式を指定できます。You can specify integer literals in decimal, octal, or hexadecimal form. 符号付きまたは符号なしの型と、long または short の型を指定できます。They can specify signed or unsigned types and long or short types.

プレフィックスまたはサフィックスが存在しない場合、コンパイラは整数リテラル値型int (32 ビット) を指定します。値が適合する場合は、 long long (64 ビット) 型になります。When no prefix or suffix is present, the compiler will give an integral literal value type int (32 bits), if the value will fit, otherwise it will give it type long long (64 bits).

10 進数の整数リテラルを指定するには、ゼロ以外の数字で指定を始めます。To specify a decimal integral literal, begin the specification with a nonzero digit. 例:For example:

int i = 157;   // Decimal literal
int j = 0198;       // Not a decimal number; erroneous octal literal
int k = 0365;       // Leading zero specifies octal literal, not decimal
int m = 36'000'000  // digit separators make large values more readable
int

8 進数の整数リテラルを指定するには、0 で指定を始め、0 ~ 7 の範囲の一連の桁を続けます。To specify an octal integral literal, begin the specification with 0, followed by a sequence of digits in the range 0 through 7. 数字の 8 と 9 は、8 進数のリテラルを指定する場合はエラーになります。The digits 8 and 9 are errors in specifying an octal literal. 例:For example:

int i = 0377;   // Octal literal
int j = 0397;        // Error: 9 is not an octal digit

16 進数の整数リテラルを指定するには、0x または 0X ("x" の大文字と小文字は区別されません) で指定を始め、09a (または A) ~ f (または F) の範囲の一連の桁を続けます。To specify a hexadecimal integral literal, begin the specification with 0x or 0X (the case of the "x" does not matter), followed by a sequence of digits in the range 0 through 9 and a (or A) through f (or F). 16 進数の a (または A) ~ f (または F) は、10 ~ 15 の範囲の値を示します。Hexadecimal digits a (or A) through f (or F) represent values in the range 10 through 15. 例:For example:

int i = 0x3fff;   // Hexadecimal literal
int j = 0X3FFF;        // Equal to i

符号なしの型を指定するには、u または U のいずれかのサフィックスを使用します。To specify an unsigned type, use either the u or U suffix. 長い型を指定するには、l または L のいずれかのサフィックスを使用します。To specify a long type, use either the l or L suffix. 64 ビットの整数型を指定するには、サフィックスとして LL、ll を使用します。To specify a 64-bit integral type, use the LL, or ll suffix. i64 サフィックスはまだサポートされていますが、Microsoft に固有なものであり移植性がないため、使用を避けることをお勧めします。The i64 suffix is still supported but should be avoided because it is specific to Microsoft and is not portable. 例:For example:

unsigned val_1 = 328u;             // Unsigned value
long val_2 = 0x7FFFFFL;                 // Long value specified
                                        //  as hex literal
unsigned long val_3 = 0776745ul;        // Unsigned long value
auto val_4 = 108LL;                           // signed long long
auto val_4 = 0x8000000000000000ULL << 16;     // unsigned long long

桁区切り記号: 単一引用符文字 (アポストロフィ) を使用して、ユーザーが読みやすくなるように、値を大きな数値で区切ることができます。Digit separators: You can use the single-quote character (apostrophe) to separate place values in larger numbers to make them easier for humans to read. 区切り記号はコンパイルに影響しません。Separators have no effect on compilation.

long long i = 24'847'458'121

浮動小数点リテラルFloating point literals

浮動小数点リテラルは、小数部分が必要な値を指定します。Floating-point literals specify values that must have a fractional part. これらの値には小数点 ( . ) が含まれ、指数を含めることができます。These values contain decimal points (.) and can contain exponents.

浮動小数点リテラルには、数値の値を指定する "仮数"、数値の大きさを指定する "指数"、およびリテラルの型を指定する省略可能なサフィックスが含まれます。Floating-point literals have a "mantissa," which specifies the value of the number, an "exponent," which specifies the magnitude of the number, and an optional suffix that specifies the literal's type. 仮数は、一連の数字の後ろにピリオドを続け、その後ろに数値の小数部分を表す省略可能な一連の数字を続けることで指定されます。The mantissa is specified as a sequence of digits followed by a period, followed by an optional sequence of digits representing the fractional part of the number. 例:For example:

18.46
38.

指数部がある場合は、次の例に示すように、10 の累乗として数値の大きさを指定します。The exponent, if present, specifies the magnitude of the number as a power of 10, as shown in the following example:

18.46e0      // 18.46
18.46e1           // 184.6

指数は e または Eを使用して指定できます。同じ意味を持ち、省略可能な符号 (+ または-) と一連の数字が続きます。The exponent may be specified using e or E, which have the same meaning, followed by an optional sign (+ or -) and a sequence of digits. 指数部がある場合、18E0 などの整数では後続の小数点は不要です。If an exponent is present, the trailing decimal point is unnecessary in whole numbers such as 18E0.

型に既定の浮動小数点リテラルdoubleします。Floating-point literals default to type double. サフィックスとして f または l (または F または L を使用します。サフィックスの大文字と小文字は区別されません)、リテラルはそれぞれfloatまたはlong doubleとして指定できます。By using the suffixes f or l (or F or L — the suffix is not case sensitive), the literal can be specified as float or long double, respectively.

long doubledouble同じ表現であるが、これらは同じ型。Although long double and double have the same representation, they are not the same type. たとえば、次のようにオーバーロードされた関数を指定できます。For example, you can have overloaded functions like

void func( double );

およびand

void func( long double );

ブール型リテラルBoolean literals

ブール型リテラルはtrueおよびfalseです。The boolean literals are true and false.

ポインター型リテラル (C++11)Pointer literal (C++11)

C++ゼロで初期化されたポインターを指定するnullptrリテラルを導入しました。C++ introduces the nullptr literal to specify a zero-initialized pointer. 移植可能なコードでは、整数型のゼロまたは NULL などのマクロの代わりにnullptrを使用する必要があります。In portable code, nullptr should be used instead of integral-type zero or macros such as NULL.

バイナリ リテラル (C++14)Binary literals (C++14)

0B または 0b をプレフィックスとして使用することにより、その後に一連の 1 と 0 が続く、バイナリ文字列を指定することができます。A binary literal can be specified by the use of the 0B or 0b prefix, followed by a sequence of 1's and 0's:

auto x = 0B001101 ; // int
auto y = 0b000001 ; // int

"マジック定数" としてリテラルを使用しないでください。Avoid using literals as "magic constants"

常に適切なプログラミング方法であるとは言えませんが、リテラルは式およびステートメント内で直接使用できます。You can use literals directly in expressions and statements although it's not always good programming practice:

if (num < 100)
    return "Success";

前の例では、"MAXIMUM_ERROR_THRESHOLD"など、明確な意味を伝達する名前付き定数を使用する方がよい場合があります。In the previous example, it might be better to use a named constant that conveys a clear meaning, for example "MAXIMUM_ERROR_THRESHOLD". 戻り値の "Success" がエンドユーザーに表示される場合は、ファイルの 1 つの場所に格納でき他の言語にローカライズできる名前付き文字列定数を使用する方がよい場合があります。And if the return value "Success" is seen by end users, then it might be better to use a named string constant that can be stored in a single location in a file from where it can be localized into other languages. 名前付き定数を使用すると、他のユーザーにとってもコードの意図が理解しやすくなります。Using named constants helps others as well as yourself to understand the intent of the code.

関連項目See also

構文規則Lexical Conventions
C++文字列リテラルC++ String Literals
C++ユーザー定義リテラルC++ User-Defined Literals