1
2
3
4

unsigned u = 10;
int i = -42;
std::cout << i + i << std::endl;  // prints -84
std::cout << u + i << std::endl;  // if 32-bit ints, prints 4294967264

1
2
3

unsigned u1 = 42, u2 = 10;
std::cout << u1 - u2 << std::endl; // ok: result is 32
std::cout << u2 - u1 << std::endl; // ok: but the result will wrap around

1
2
3

// WRONG: u can never be less than 0; the condition will always succeed
for (unsigned u = 10; u >= 0; --u)
    std::cout << u << std::endl;

1

3.14159    3.14159E0    0.    0e0    .001

1
2

'a'  // character literal
"Hello World!"  // string literal

1
2
3

// multiline string literal
std::cout << "a really, really long string literal "
             "that spans two lines" << std::endl;

1
2
3
4

newline            \n     horizontal tab      \t     alert (bell)       \a
vertical tab       \v     backspace          \b     double quote  \"
backslash         \\     question mark     \?     single quote    \'
carriage return   \r     formfeed       \f"

1
2

\7 (bell)    \12 (newline)     \40 (blank)
\0 (null)    \115 ('M')    \x4d ('M')

1
2
3
4
5

L'a'     // wide character literal, type is wchar_t
u8"hi!"  // utf-8 string literal (utf-8 encodes a Unicode character in 8 bits)
42ULL    // unsigned integer literal, type is unsigned long long
1E-3F    // single-precision floating-point literal, type is float
3.14159L // extended-precision floating-point literal, type is long double

1
2
3
4
5

int sum = 0, value, // sum, value, and units_sold have type int
    units_sold = 0; // sum and units_sold have initial value 0
Sales_item item;    // item has type Sales_item (see § 1.5.1 (p. 20))
// string is a library type, representing a variable-length sequence of characters
std::string book("0-201-78345-X"); // book initialized from string literal

1
2
3
4

// ok: price is defined and initialized before it is used to initialize discount
double price = 109.99, discount = price * 0.16;
// ok: call applyDiscount and use the return value to initialize salePrice
double salePrice = applyDiscount(price, discount);

1
2
3
4

int units_sold = 0;
int units_sold = {0};
int units_sold{0};
int units_sold(0);

1
2
3

long double ld = 3.1415926536;
int a{ld}, b = {ld}; // error: narrowing conversion required
int c(ld), d = ld;   // ok: but value will be truncated

1
2

extern int i;   // declares but does not define i
int j;          // declares and defines j

1

extern double pi = 3.1416; // definition

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

alignas          continue         friend           register         true
alignof          decltype         goto             reinterpret_cast try
asm              default          if               return           typedef
auto             delete           inline           short            typeid
bool             do               int              signed           typename
break            double           long             sizeof           union
case             dynamic_cast     mutable          static           unsigned
catch            else             namespace        static_assert    using
char             enum             new              static_cast      virtual
char16_t         explicit         noexcept         struct           void
char32_t         export           nullptr          switch           volatile
class            extern           operator         template         wchar_t
const            false            private          this             while
constexpr        float            protected        thread_local
const_cast       for              public           throw

1
2

and    bitand compl not_eq or_eq xor_eq
and_eq bitor  not   or     xor

1
2
3
4
5
6
7
8

int reused = 42;  // reused has global scope
int main()
{
    std::cout << reused << std::endl; // global reused
    int reused = 0; // local reused hides global one
    std::cout << reused << std::endl;
    std::cout << ::reused << std::endl; // explicitly requests the global reused
}

1
2
3

int ival = 1024;
int &refVal = ival;  // refVal refers to (is another name for) ival
int &refVal2;        // error: a reference must be initialized

1
2
3
4

int i = 1024, i2 = 2048;  // i and i2 are both ints
int &r = i, r2 = i2;      // r is a reference bound to i; r2 is an int
int i3 = 1024, &ri = i3;  // i3 is an int; ri is a reference bound to i3
int &r3 = i3, &r4 = i2;   // both r3 and r4 are references

1
2
3

int &refVal4 = 10;   // error: initializer must be an object
double dval = 3.14;
int &refVal5 = dval; // error: initializer must be an int object

1
2

int *ip1, *ip2;  // both ip1 and ip2 are pointers to int
double dp, *dp2; // dp2 is a pointer to double; dp is a double

1
2

int ival = 42;
int *p = &ival; // p holds the address of ival; p is a pointer to ival

1
2
3
4
5

double dval;
double *pd = &dval;  // ok: initializer is the address of a double
double *pd2 = pd;    // ok: initializer is a pointer to double
int *pi = pd;  // error: types of pi and pd differ
pi = &dval;    // error: assigning the address of a double to a pointer to int

1
2
3

int ival = 42;
int *p = &ival; // p holds the address of ival; p is a pointer to ival
cout << *p;     // * yields the object to which p points; prints 42

1
2
3
4

int *p1 = nullptr; // equivalent to int *p1 = 0;
int *p2 = 0;       // directly initializes p2 from the literal constant 0
// must #include cstdlib
int *p3 = NULL;    // equivalent to int *p3 = 0;

1
2

const int *p = nullptr;     // p is a pointer to a const int
constexpr int *q = nullptr; // q is a const pointer to int

1
2

const int *p = nullptr;     // p is a pointer to a const int
constexpr int *q = nullptr; // q is a const pointer to int

1
2
3
4
5

using SI = Sales_item;  // SI is a synonym for Sales_item

typedef char *pstring;
const pstring cstr = 0; // cstr is a constant pointer to char
const pstring *ps;      // ps is a pointer to a constant pointer to char

1
2
3

auto item = val1 + val2;
auto i = 0, *p = &i;      // ok: i is int and p is a pointer to int
auto sz = 0, pi = 3.14;   // error: inconsistent types for sz and pi

1
2

int i = 0, &r = i;
auto a = r;  // a is an int (r is an alias for i, which has type int)

1
2
3
4
5

const int ci = i, &cr = ci;
auto b = ci;  // b is an int (top-level const in ci is dropped)
auto c = cr;  // c is an int (cr is an alias for ci whose const is top-level)
auto d = &i;  // d is an int*(& of an int object is int*)
auto e = &ci; // e is const int*(& of a const object is low-level const)

1

const auto f = ci; // deduced type of ci is int; f has type const int

1
2
3
4
5
6
7
8

auto &g = ci;       // g is a const int& that is bound to ci
auto &h = 42;       // error: we can't bind a plain reference to a literal
const auto &j = 42; // ok: we can bind a const reference to a literal

auto k = ci, &l = i;    // k is int; l is int&
auto &m = ci, *p = &ci; // m is a const int&;p is a pointer to const int
// error: type deduced from i is int; type deduced from &ci is const int
auto &n = i, *p2 = &ci;

1

decltype(f()) sum = x; // sum has whatever type f returns

1
2
3
4

const int ci = 0, &cj = ci;
decltype(ci) x = 0; // x has type const int
decltype(cj) y = x; // y has type const int& and is bound to x
decltype(cj) z;     // error: z is a reference and must be initialized

1
2
3
4
5
6
7

int i = 42, *p = &i, &r = i;
decltype(r + 0) b;  // ok: addition yields an int; b is an (uninitialized) int
decltype(*p) c;     // error: c is int& and must be initialized

// decltype of a parenthesized variable is always a reference
decltype((i)) d;    // error: d is int& and must be initialized
decltype(i) e;      // ok: e is an (uninitialized) int