深入探索C++之旅

需积分: 10 51 浏览量更新于2024-07-21 收藏 1.44MB PDF 举报

"A Tour of C++ 是一本深入学习C++编程语言的书籍，由C++的设计者和最初实现者Bjarne Stroustrup编辑。该系列旨在为程序员提供可靠、聚焦的信息，每本书要么专注于一个特定主题，以适合该主题的技术深度进行探讨，要么提供快速的综合概览，帮助读者快速理解更广泛的C++语言特性。其实践导向的方法旨在提升专业（或有志于专业）程序员的技能水平和知识深度。随着C++的发展，能够区分关键信息与宣传和花哨特性变得越来越重要，而这个系列正提供了深入内容和实用指导，以支持持续的技能发展。" "A Tour of C++" 作为C++深入系列的一部分，可能涵盖了以下C++的重要知识点： 1. **基础语法**：包括变量声明、数据类型、运算符、流程控制（如if语句、循环）、函数的定义和调用等。 2. **对象和类**：C++的核心特性是面向对象编程，书中可能会详细介绍类的创建、对象的实例化、封装、继承和多态等概念。 3. **模板**：C++中的模板允许创建泛型代码，可以用于处理不同类型的参数，包括函数模板和类模板。 4. **异常处理**：C++中的异常处理机制，如try-catch-finally块，用于处理程序运行时可能出现的错误。 5. **STL（标准模板库）**：包括容器（如vector、list、set等）、算法（如排序、查找等）和迭代器，这些都是高效编程的关键工具。 6. **智能指针**：如unique_ptr、shared_ptr和weak_ptr，它们是C++11引入的特性，用于管理动态内存，防止内存泄漏。 7. **RAII（Resource Acquisition Is Initialization）**：一种编程策略，确保资源在创建时被获取并在不再需要时自动释放。 8. **C++11/14/17/20新特性**：如lambda表达式、右值引用、自动类型推断（auto关键字）、并发编程支持等。 9. **内存管理和性能优化**：讨论如何有效地使用堆栈和堆，以及如何通过内存对齐和内联函数等手段优化程序性能。 10. **设计模式**：书中可能介绍了一些常见的设计模式，如工厂模式、单例模式、观察者模式等，这些模式在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

www.it-ebooks.info

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.

www.it-ebooks.info

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.

www.it-ebooks.info

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

www.it-ebooks.info

剩余192页未读，继续阅读

johnson04

粉丝: 0
资源: 4

深入探索C++之旅

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

新版图书 A.Tour.of.C++.2nd.Edition.2018.7

A Tour of C++, 2nd Edition

a tour of 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 2018.7 epub

a tour of c++ 3rd

a tour of c++ 3rd download

最新资源