Bjarne Stroustrup深度解析C++ (2013): 实用教程与专家见解

需积分: 9 57 浏览量更新于2024-07-17 收藏 802KB PDF 举报

"《Bjarne Stroustrup A Tour of C++ (2013):深入探索之旅》是一本由C++的设计者和最初实现者Bjarne Stroustrup主编的专业系列书籍。该系列旨在为现实世界的程序员提供关于C++编程语言的可靠信息，特别强调深度和实用性。每一本书都由该领域的专家撰写，无论是单个主题的深入探讨，还是对语言更广泛特性的快速概述，内容都以技术角度为依据，适合不同层次的学习者。书名中的“Tour”意味着读者可以跟随作者Bjarne Stroustrup进行一次C++的系统性探索，从基础概念到高级技术，旨在提升专业程序员的技能和知识。系列的特点是内容精炼且聚焦，避免了无关的干扰，使读者能够专注于关键信息。随着C++的发展，理解其核心原理、去除市场炒作和表面装饰变得越来越重要，而《A Tour of C++》正是提供这些深度内容和实用指导的工具箱。每一本书都提供了必要的背景知识、实用工具、概念和技术，使得无论是初学者还是有经验的开发者都能从中获益。无论是希望深入学习某个特定领域的程序员，还是需要快速了解新特性以便在实际项目中应用的专业人士，这个系列都是理想的参考资料。《Bjarne Stroustrup A Tour of 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页未读，继续阅读

c849475590

粉丝: 1
资源: 12

Bjarne Stroustrup深度解析C++ (2013): 实用教程与专家见解

C++速览：A.Tour.of.C++.2014 - Bjarne Stroustrup原著解读

C++17与C++20新特性深度解析：A.Tour.of.C++2nd.Edition.2018升级指南

深入探索C++：Bjarne Stroustrup精选指南

A.Tour.of.C++.2nd.Edition.2018.7.zip

A Tour of C++ - Stroustrup, Bjarne - Addison Wesley Professional

A Tour of C++ 2nd Edition 2018.7 epub

深入探索C++：Bjarne Stroustrup权威指南

在《C++速览：A.Tour.of.C++.2014》一书中，Bjarne Stroustrup是如何向初学者介绍C++的模板和STL的？请结合实例详细说明。

Bjarne Stroustrup的《C++速览：A Tour of C++》是如何帮助初学者快速掌握C++核心概念的？请结合书籍内容详细说明。

在《C++速览：A Tour of C++》中，Bjarne Stroustrup如何引导初学者快速理解并掌握C++的面向对象编程特性？

最新资源