1.If we assign an out-of-range value to an object of unsigned type, the result is
the remainder of the value modulo the number of values the target type can
hold. For example, an 8-bit unsigned char can hold values from 0 through
255, inclusive. If we assign a value outside this range, the compiler assigns the
remainder of that value modulo 256. Therefore, assigning –1 to an 8-bit
unsigned char gives that object the value 255.

2. If we assign an out-of-range value to an object of signed type, the result is

undefined. The program might appear to work, it might crash, or it might

produce garbage values.

3.Advice: Avoid Undefined and Implementation-Defined Behavior

Undefined behavior results from errors that the compiler is not required (and

sometimes is not able) to detect. Even if the code compiles, a program that

executes an undefined expression is in error.

Unfortunately, programs that contain undefined behavior can appear to

execute correctly in some circumstances and/or on some compilers. There is

no guarantee that the same program, compiled under a different compiler or

even a subsequent release of the same compiler, will continue to run

correctly. Nor is there any guarantee that what works with one set of inputs

will work with another.

Similarly, programs usually should avoid implementation-defined behavior,

such as assuming that the size of an int is a fixed and known value. Such

programs are said to be nonportable. When the program is moved to another

machine, code that relied on implementation-defined behavior may fail.

Tracking down these sorts of problems in previously working programs is,

mildly put, unpleasant.

4. The compiler applies these same type conversions when we use a value of one

arithmetic type where a value of another arithmetic type is expected. For example,

when we use a nonbool value as a condition (§ 1.4.1, p. 12), the arithmetic value is

converted to bool in the same way that it would be converted if we had assigned

that arithmetic value to a bool variable:

int i = 42;

if (i) // condition will evaluate as true

i = 0;

If the value is 0, then the condition is false; all other (nonzero) values yield true.

By the same token, when we use a bool in an arithmetic expression, its value

always converts to either 0 or 1. As a result, using a bool in an arithmetic expression

is almost surely incorrect.

5. Caution: Don’t Mix Signed and Unsigned Types

Expressions that mix signed and unsigned values can yield surprising results

when the signed value is negative. It is essential to remember that signed

values are automatically converted to unsigned. For example, in an

expression like a * b, if a is -1 and b is 1, then if both a and b are ints,

the value is, as expected -1. However, if a is int and b is an unsigned,

then the value of this expression depends on how many bits an int has on

the particular machine. On our machine, this expression yields 4294967295

6.2的32次方是4294967296

7.

unsigned u = 10, u2 = 42;

std::cout << u2 - u << std::endl;//32

std::cout << u - u2 << std::endl;//4294967264

int i = 10, i2 = 42;

std::cout << i2 - i << std::endl;//32

std::cout << i - i2 << std::endl;//-32

std::cout << i - u << std::endl;//0

1.

Although integer literals may be stored in signed types, technically speaking, the

value of a decimal literal is never a negative number. If we write what appears to be

a negative decimal literal, for example, -42, the minus sign is not part of the literal.

The minus sign is an operator that negates the value of its (literal) operand.

2.

3. The type of a string literal is array of constant chars, a type we’ll discuss in § 3.5.4

(p. 122). The compiler appends a null character (’\0’) to every string literal. Thus, the

actual size of a string literal is one more than its apparent size. For example, the

literal ‘A‘ represents the single character A, whereas the string literal "A" represents

an array of two characters, the letter A and the null character.

4. Two string literals that appear adjacent to one another and that are separated only

by spaces, tabs, or newlines are concatenated into a single literal. We use this form of

literal when we need to write a literal that would otherwise be too large to fit

comfortably on a single line:

// multiline string literal

std::cout << "a really, really long string literal "

"that spans two lines" << std::endl;

学习笔记（C++Primer）--易错点总结（Chapter2）