Freigeben über

C++ Integer Constants

  • Artikel

Integer constants are constant data elements that have no fractional parts or exponents. They always begin with a digit. You can specify integer constants in decimal, octal, or hexadecimal form. They can specify signed or unsigned types and long or short types.

Grammar

  • integer-constant:
    decimal-constant integer-suffixopt

    octal-constant integer-suffixopt

    hexadecimal-constant integer-suffixopt

    'c-char-sequence'

  • decimal-constant:
    nonzero-digit

    decimal-constant digit

  • octal-constant:
    0

    octal-constant octal-digit

  • hexadecimal-constant:
    0xhexadecimal-digit

    0Xhexadecimal-digit

    hexadecimal-constant hexadecimal-digit

  • nonzero-digit: one of
    1 2 3 4 5 6 7 8 9

  • octal-digit: one of
    0 1 2 3 4 5 6 7

  • hexadecimal-digit: one of
    0 1 2 3 4 5 6 7 8 9

    a b c d e f

    A B C D E F

  • integer-suffix:
    unsigned-suffix long-suffixopt

    long-suffix unsigned-suffixopt

  • unsigned-suffix: one of
    u U

  • long-suffix: one of
    l L

  • 64-bit integer-suffix:
    i64 LL ll

To specify integer constants using octal or hexadecimal notation, use a prefix that denotes the base. To specify an integer constant of a given integral type, use a suffix that denotes the type.

To specify a decimal constant, begin the specification with a nonzero digit. For example:

int i = 157;   // Decimal constant
int j = 0198;  // Not a decimal number; erroneous octal constant
int k = 0365;  // Leading zero specifies octal constant, not decimal

To specify an octal constant, begin the specification with 0, followed by a sequence of digits in the range 0 through 7. The digits 8 and 9 are errors in specifying an octal constant. For example:

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

To specify a hexadecimal constant, 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). Hexadecimal digits a (or A) through f (or F) represent values in the range 10 through 15. For example:

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

To specify an unsigned type, use either the u or U suffix. To specify a long type, use either the l or L suffix. For example:

unsigned uVal = 328u;             // Unsigned value
long lVal = 0x7FFFFFL;            // Long value specified 
                                  //  as hex constant
unsigned long ulVal = 0776745ul;  // Unsigned long value

To specify a 64-bit integral type, use the LL, ll or i64 suffix. For example,

// 64bitsuffix.cpp
#include <stdio.h>
enum MyEnum {
   IntType,
   Int64Type
};

MyEnum f1(int) {
   printf("in f1(int)\n");
   return IntType;
}

MyEnum f1(__int64) {
   printf_s("in f1(__int64)\n");
   return Int64Type;
}

int main() {
   MyEnum t1 = f1(0x1234), t2 = f1(0x1234i64);
}

Output

in f1(int)
in f1(__int64)

See Also

Reference

C++ Literals