深度探索C++：Bjarne斯特劳斯编著的专业指南

5星 · 超过95%的资源需积分: 10 74 浏览量更新于2024-07-23 收藏 853KB PDF 举报

《C++深度之旅》是一本由Bjarne Stroustrup编写的书籍，他是C++语言的设计者和早期实现者。这本书作为"The C++ In-Depth Series"的一部分，旨在为实际编程世界的专业人士提供关于C++编程语言的深入、可靠信息。系列书籍的特点是内容紧凑且聚焦，每一本都由该领域的专家撰写，旨在满足不同主题的技术需求。 Stroustrup亲自挑选的这些书籍，无论是一篇专题论文还是对更广泛语言特性的快速概览，都力求实用，帮助读者提升编程技能或深化对C++的理解。作者们确保了内容的专业性，避免了无关的干扰，以便读者能够专注于核心信息。随着C++的不断发展，理解其本质、区分事实与炒作以及找到实际开发所需的深度内容变得越来越重要。《C++深度之旅》系列书正是提供了这样的背景知识、工具、概念和技术指南，使读者能够在这个复杂而强大的编程语言中游刃有余，无论是初学者还是经验丰富的开发者都能从中获益匪浅。这本书不仅适合希望通过深入学习来提升C++能力的程序员，也适合那些希望快速掌握新特性或扩展现有知识库的专业人员。阅读时，读者可以按需查阅，迅速找到所需的信息，而不必在大量冗余内容中浪费时间。《C++深度之旅》是一本值得推荐的实用指南，对于所有渴望深入了解C++语言的人来说，它是一次高效且富有价值的探索之旅。

ptg11539604

Section 1.4 Functions 5

void print(int,double);

void print(double ,int);

void user2()

{

print(0,0); // error : ambiguous

}

This is known as function overloading and is one of the essential parts of generic programming

(§5.4). When a function is overloaded, each function of the same name should implement the same

semantics. The

print() functions are an example of this; each print() prints its argument.

1.5 Types, Variables, and Arithmetic

Every name and every expression has a type that determines the operations that may be performed

on it. For example, the declaration

int inch;

speciﬁes that inch is of type int; that is, inch is an integer variable.

A declaration is a statement that introduces a name into the program. It speciﬁes a type for the

named entity:

•Atype deﬁnes a set of possible values and a set of operations (for an object).

•Anobject is some memory that holds a value of some type.

•Avalue is a set of bits interpreted according to a type.

•Avariable is a named object.

C++ offers a variety of fundamental types. For example:

bool // Boolean, possible values are true and false

char // character, for example, 'a', 'z', and '9'

int // integer, for example, -273, 42, and 1066

double // double-precision ﬂoating-point number, for example, -273.15, 3.14, and 299793.0

unsigned // non-negative integer, for example, 0, 1, and 999

Each fundamental type corresponds directly to hardware facilities and has a ﬁxed size that deter-

mines the range of values that can be stored in it:

bool:

char:

int:

double:

A char variable is of the natural size to hold a character on a given machine (typically an 8-bit

byte), and the sizes of other types are quoted in multiples of the size of a

char. The size of a type is

implementation-deﬁned (i.e., it can vary among different machines) and can be obtained by the

ptg11539604

Section 1.5 Types, Variables, and Arithmetic 7

complex<double> z = 1; // a complex number with double-precision ﬂoating-point scalars

complex<double> z2 {d1,d2};

complex<double> z3 = {1,2}; // the = is optional with { ... }

vector<int> v {1,2,3,4,5,6}; // a vector of ints

The = form is traditional and dates back to C, but if in doubt, use the general {}-list form. If nothing

else, it saves you from conversions that lose information:

int i1 = 7.2; // i1 becomes 7 (surpr ise?)

int i2 {7.2}; // error : ﬂoating-point to integer conversion

int i3 = {7.2}; // error : ﬂoating-point to integer conversion (the = is redundant)

Unfortunately, conversions that lose information, narrowing conversions, such as double to int and

int to char are allowed and implicitly applied. The problems caused by implicit narrowing conver-

sions is a price paid for C compatibility (§14.3).

A constant (§1.7) cannot be left uninitialized and a variable should only be left uninitialized in

extremely rare circumstances. Don’t introduce a name until you have a suitable value for it. User-

deﬁned types (such as

string, vector, Matrix, Motor_controller, and Orc_warrior) can be deﬁned to be

implicitly initialized (§4.2.1).

When deﬁning a variable, you don’t actually need to state its type explicitly when it can be

deduced from the initializer:

auto b = true; // a bool

auto ch = 'x'; // a char

auto i = 123; // an int

auto d = 1.2; // a double

auto z = sqrt(y); // z has the type of whatever sqr t(y) retur ns

With auto, we use the = because there is no potentially troublesome type conversion involved.

We use

auto where we don’t hav e a speciﬁc reason to mention the type explicitly. ‘‘Speciﬁc

reasons’’ include:

• The deﬁnition is in a large scope where we want to make the type clearly visible to readers

of our code.

• We want to be explicit about a variable’s range or precision (e.g.,

double rather than ﬂoat).

Using

auto, we avoid redundancy and writing long type names. This is especially important in

generic programming where the exact type of an object can be hard for the programmer to know

and the type names can be quite long (§10.2).

In addition to the conventional arithmetic and logical operators, C++ offers more speciﬁc opera-

tions for modifying a variable:

x+=y // x = x+y

++x // increment: x = x+1

x−=y // x = x-y

−−x // decrement: x = x-1

x∗=y // scaling: x = x*y

x/=y // scaling: x = x/y

x%=y // x = x%y

These operators are concise, convenient, and very frequently used.

ptg11539604

8 The Basics Chapter 1

1.6 Scope and Lifetime

A declaration introduces its name into a scope:

• Local scope: A name declared in a function (§1.4) or lambda (§5.5) is called a local name.

Its scope extends from its point of declaration to the end of the block in which its declara-

tion occurs. A block is delimited by a

{}pair. Function argument names are considered

local names.

• Class scope: A name is called a member name (or a class member name) if it is deﬁned in a

class (§2.2, §2.3, Chapter 4), outside any function (§1.4), lambda (§5.5), or

enum class

(§2.5). Its scope extends from the opening { of its enclosing declaration to the end of that

declaration.

• Namespace scope: A name is called a namespace member name if it is deﬁned in a name-

space (§3.3) outside any function, lambda (§5.5), class (§2.2, §2.3, Chapter 4), or

enum

class

(§2.5). Its scope extends from the point of declaration to the end of its namespace.

A name not declared inside any other construct is called a global name and is said to be in the

global namespace.

In addition, we can have objects without names, such as temporaries and objects created using

new (§4.2.2). For example:

vector<int> vec; // vec is global (a global vector of integers)

struct Record {

string name; // name is a member (a string member)

// ...

};

void fct(int arg) // fct is global (a global function)

// arg is local (an integer argument)

{

string motto {"Who dares win"}; // motto is local

auto p = new Record{"Hume"}; // p points to an unnamed Record (created by new)

// ...

}

An object must be constructed (initialized) before it is used and will be destroyed at the end of its

scope. For a namespace object the point of destruction is the end of the program. For a member,

the point of destruction is determined by the point of destruction of the object of which it is a mem-

ber. An object created by

new ‘‘lives’’ until destroyed by delete (§4.2.2).

1.7 Constants

C++ supports two notions of immutability:

•

const: meaning roughly ‘‘I promise not to change this value.’’ This is used primarily to

specify interfaces, so that data can be passed to functions without fear of it being modiﬁed.

The compiler enforces the promise made by

const.

ptg11539604

Section 1.7 Constants 9

•

constexpr: meaning roughly ‘‘to be evaluated at compile time.’’ This is used primarily to

specify constants, to allow placement of data in read-only memory (where it is unlikely to

be corrupted) and for performance.

For example:

const int dmv = 17; // dmv is a named constant

int var = 17; // var is not a constant

constexpr double max1 = 1.4∗square(dmv); // OK if square(17) is a constant expression

constexpr double max2 = 1.4∗square(var); // error : var is not a constant expression

const double max3 = 1.4∗square(var); // OK, may be evaluated at run time

double sum(const vector<double>&); // sum will not modify its argument (§1.8)

vector<double> v {1.2, 3.4, 4.5}; // v is not a constant

const double s1 = sum(v); // OK: evaluated at run time

constexpr double s2 = sum(v); // error : sum(v) not constant expression

For a function to be usable in a constant expression, that is, in an expression that will be evaluated

by the compiler, it must be deﬁned

constexpr. For example:

constexpr double square(double x) { return x∗x; }

To be constexpr, a function must be rather simple: just a return-statement computing a value. A

constexpr function can be used for non-constant arguments, but when that is done the result is not a

constant expression. We allow a

constexpr function to be called with non-constant-expression argu-

ments in contexts that do not require constant expressions, so that we don’t hav e to deﬁne essen-

tially the same function twice: once for constant expressions and once for variables.

In a few places, constant expressions are required by language rules (e.g., array bounds (§1.8),

case labels (§1.9), template value arguments (§5.2), and constants declared using

constexpr). In

other cases, compile-time evaluation is important for performance. Independently of performance

issues, the notion of immutability (of an object with an unchangeable state) is an important design

concern.

1.8 Pointers, Arrays, and References

An array of elements of type char can be declared like this:

char v[6]; // array of 6 characters

Similarly, a pointer can be declared like this:

char∗ p; // pointer to character

In declarations, []means ‘‘array of’’ and ∗ means ‘‘pointer to.’’ All arrays have 0 as their lower

bound, so

v has six elements, v[0] to v[5]. The size of an array must be a constant expression (§1.7).

A pointer variable can hold the address of an object of the appropriate type:

char∗ p = &v[3]; // p points to v’s four th element

char x = ∗p; // *p is the object that p points to

剩余192页未读，继续阅读

jichao1989

粉丝: 1
资源: 6

深度探索C++：Bjarne斯特劳斯编著的专业指南

A Tour of C++

C++ 旅程

Exploring C++

A Tour of C++ 2nd

The C++ Programming Language& A Tour of C++

A Tour of C++ 2nd Edition epub

A Tour of C++, 2nd Edition

C++语言导学 A Tour of C++（C++之父写的入门书）

a tour of c++ 3rd

a tour of c++ 3rd download

最新资源