C++14深度探索：现代编程语言之旅

需积分: 6 87 浏览量更新于2024-07-18 收藏 858KB PDF 举报

"A Tour of C++ 2014" 是一本旨在为经验丰富的程序员提供现代C++语言概览的轻量级书籍。相较于C++98版本，C++11引入了许多改进，使得表达思想更加清晰、简单且直接，同时通过更严格的编译器检查，确保程序质量并提升运行效率。作者Bjarne Stroustrup，作为C++的设计者和最初实现者，以其深厚的专业知识，精心挑选和撰写了一系列深入浅出的书籍，"The C++ In-Depth Series" 就是其中一部分。这本书涵盖了C++11的主要语言特性，以及标准库的关键组件，适合那些已经具备编程基础的读者快速入门。尽管篇幅不长，但其目标并非追求全面精通，而是为程序员提供一个起点，通过关键示例和概述，帮助他们开启C++之旅。对于渴望深入了解的人来说，Bjarne Stroustrup的《The C++ Programming Language, Fourth Edition》(TC++PL4) 是一个更详尽的选择，这本书的第二至第五章内容与"A Tour of C++" 相对应，而且本书也对其进行了扩展和改进，使其成为相对独立的学习资源。阅读这本书之前，建议对编程有一定了解，如果刚接触编程，可以参考Stroustrup的《Programming: Principles and Practice Using C++》来打下基础。C++的风格与过去或不同领域的编程可能有所差异，因此理解和掌握C++11的编程范式至关重要。"The C++ In-Depth Series" 的系列特点在于，它专注于提供实用的信息，帮助专业人士避免无关的干扰，深入理解语言的核心内容和实践指导，这对于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页未读，继续阅读

ytmforever

粉丝: 1
资源: 6

C++14深度探索：现代编程语言之旅

A Tour of C++, 2nd Edition

A Tour of C++

a tour of c++

A Tour of C++ 2nd

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

A Tour of C++ 2nd Edition epub

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

a tour of c++ 3rd

a tour of c++ 3rd download

a tour of c++: the basics

最新资源