快速掌握经典C++入门书：EssentialC++实战指南

需积分: 50 28 浏览量更新于2024-07-26 收藏 920KB PDF 举报

"《Essential C++》是一本由Stanley B. Lippman编著的经典C++入门教材，由Addison Wesley出版社于2002年9月出版，ISBN号为0-201-48518-4，共416页。这本书因其重要性和实用性在C++编程领域备受推崇。对于那些希望快速掌握C++的程序员，特别是那些时间紧张的实践者来说，它提供了一条高效的学习路径。作者通过精心设计，将这个原本复杂且广泛的主题精简到初学者必须了解的核心内容，使读者能在短时间内熟悉C++语言。书中不仅涵盖了程序设计的基本概念，还重点介绍了面向过程、泛型、面向对象以及面向对象编程（OOP）的基础，这些都是编写实用程序的关键要素。Lippman通过一系列递增难度的编程问题来组织内容，每解决一个问题都会引入新的语言特性或技术，这种方法有助于读者在实际操作中理解和应用这些知识。书中强调的是在解决问题的过程中学习，而非单纯理论堆砌。对于日常工作中可能会遇到的编程挑战，如数据结构、算法设计、异常处理等，作者都提供了深入浅出的探讨。此外，书中案例研究的有效性得到了Steve Vinoski的高度评价，他指出这使得学习过程既系统又富有连贯性，有助于培养真正的编程技能。《Essential C++》是那些想要在短时间内提升C++技能、迅速适应工作需求的专业人士的理想选择。它不仅适合初学者，也适合有一定基础但希望进一步巩固和深化理解的开发者。通过本书，读者可以建立起坚实的C++编程基础，并掌握应对实际项目所需的核心技术和最佳实践。"

A class is a programmer-defined data type. C++ also provides a set of built-in data types: Boolean, integer,

floating point, and character. A keyword is associated with each one to allow us to specify the data type.

For example, to store the value entered by the user, we define an integer data object:

int usr_val;

int

is a language keyword identifying usr_val as a data object of integer type. Both the number of

guesses a user makes and the number of correct guesses are also integer objects. The difference here is that

we wish to set both of them to an initial value of 0. We can define each on a separate line:

int num_tries = 0;

int num_right = 0;

Or we can define them in a single comma-separated declaration statement:

int num_tries = 0, num_right = 0;

In general, it is a good idea to initialize data objects even if the value simply indicates that the object has

no useful value as yet. I didn't initialize

usr_val because its value is set directly from the user's input

before the program makes any use of the object.

An alternative initialization syntax, called a constructor syntax, is

int num_tries(0);

I know. Why are there two initialization syntaxes? And, worse, why am I telling you this now? Well, let's

see whether the following explanation satisfies either or both questions.

The use of the assignment operator (

=) for initialization is inherited from the C language. It works well

with the data objects of the built-in types and for class objects that can be initialized with a single value,

such as the string class:

string sequence_name = "Fibonacci";

It does not work well with class objects that require multiple initial values, such as the standard library

complex number class, which can take two initial values: one for its real component and one for its

imaginary component. The alternative constructor initialization syntax was introduced to handle multiple

value initialization:

#include <complex>

complex<double> purei(0, 7);

The strange bracket notation following complex indicates that the complex class is a template class. We'll

see a great deal more of template classes throughout the book. A template class allows us to define a class

without having to specify the data type of one or all of its members.

The complex number class, for example, contains two member data objects. One member represents the

real component of the number. The second member represents the imaginary component of the number.

These members need to be floating point data types, but which ones? C++ generously supports three

floating point size types: single precision, represented by the keyword

float; double precision,

represented by the keyword

double; and extended precision, represented by the two keywords long

double.

The template class mechanism allows the programmer to defer deciding on the data type to use for a

template class. It allows the programmer to insert a placeholder that is later bound to an actual data type. In

the preceding example, the user chose to bind the data type of the complex class members to

double.

I know, this probably raises scads more questions than it answers. However, it is because of templates that

C++ supports two initialization syntaxes for the built-in data types. When the built-in data types and

programmer-defined class types had separate initialization syntaxes, it was not possible to write a template

that supported both built-in and class data types. Making the syntax uniform simplified template design.

Unfortunately, explaining the syntax seems to have become more complicated!

The user's running score must to be a floating point value because it may be some percentage. We'll define

it to be of type

double:

double usr_score = 0.0;

We also need to keep track of the user's yes/no responses: Make another try? Try another sequence?

We can store the user's response in a character data object:

char usr_more;

cout << "Try another sequence? Y/N? ";

cin >> usr_more;

The char keyword represents a character type. A character marked by a pair of single quotations

represents a character literal:

'a', '7', ';', and so on. Some special built-in character literals are the

following (they are sometimes called escape sequences):

'\n' newline

'\t' tab

'\0' null

'\'' single quote

'\"' double quote

'\\' backslash

For example, to generate a newline and then tab before printing the user's name, we might write

cout << '\n' << '\t' << user_name;

Alternatively, we can concatentate single characters into a string:

cout << "\n\t" << user_name;

Typically, we use these special characters within string literals. For example, to represent a literal file path

under Windows, we need to escape the backslash:

"F:\\essential\\programs\\chapter1\\ch1_main.cpp";

C++ supports a built-in Boolean data type to represent true/false values. In our program, for example, we

can define a Boolean object to control whether to display the next numeric sequence:

bool go_for_it = true;

A Boolean object is specified with the bool keyword. It can hold one of two literal values, either true or

false.

All the data objects defined so far modified during the course of our program. go_for_it, for example,

eventually gets set to

false. usr_score is potentially updated with each user guess.

Sometimes, however, we need an object to represent a constant value: the maximum number of guesses to

allow a user, for example, or the value of pi. The objects holding these values should not be modified

during the course of our program. How can we prevent the accidental modification of such objects? We

can enlist the aid of the language by declaring these objects as

const:

const int max_tries = 3;

const double pi = 3.14159;

A const object cannot be modified from its initial value. Any attempt to assign a value to a const object

results in a compile-time error. For example:

max_tries = 42; // error: const object

1.3 Writing Expressions

The built-in data types are supported by a collection of arithmetic, relational, logical, and compound

assignment operators. The arithmetic operators are unsurprising except for integer division and the

remainder operator:

// Arithmetic Operators

+ addition a + b

- subtraction a - b

* multiplication a * b

/ division a / b

% remainder a % b

The division of two integer values yields a whole number. Any remainder is truncated; there is no

rounding. The remainder is accessed using the

% operator:

5 / 3 evaluates to 1 while 5 % 3 evaluates to 2

5 / 4 evaluates to 1 while 5 % 4 evaluates to 1

5 / 5 evaluates to 1 while 5 % 5 evaluates to 0

When might we actually use the remainder operator? Imagine that we want to print no more than eight

strings on a line. If the number of words on the line is less than eight, we output a blank space following

the word. If the string is the eighth word on the line, we output a newline. Here is our implementation:

const int line_size = 8;

int cnt = 1;

// these statements are executed many times, with

// a_string representing a different value each time

// and cnt growing by one with each execution ...

cout << a_string

<< (cnt % line_size ? ' ' : '\n');

The parenthetical expression following the output operator likely makes no sense to you unless you are

already familiar with the conditional operator (

?:). The result of the expression is to output either a space

or a newline character depending on whether the remainder operator evaluates to a zero or a nonzero value.

Let's see what sense we can make of it.

The expression

cnt % line_size

evaluates to zero whenever cnt is a multiple of line_size; otherwise, it evaluates to a nonzero value.

Where does that get us? The conditional operator takes the following general form:

expr

? execute_if_expr_is_true

: execute_if_expr_is_false;

If expr evaluates to true, the expression following the question mark is evaluated. If expr evaluates to

false, the expression following the colon is evaluated. In our case, the evaluation is to feed either a space or

a newline character to the output operator.

A conditional expression is treated as evaluating to false if its value is zero. Any nonzero value is treated

as true. In this example, whenever

cnt is not a multiple of eight, the result is nonzero, the true branch of

the conditional operator is evaluated, and a space is printed.

A compound assignment operator provides a shorthand notation for applying an arithmetic operation on

the object to be assigned. For example, rather than write

cnt = cnt + 2;

a C++ programmer typically writes

cnt += 2; // add 2 to the current value of cnt

A compound assignment operator is associated with each arithmetic operator: +=, -=, *=, /=, and %=.

When an object is being added to or subtracted by 1, the C++ programmer uses the increment and

decrement operators:

cnt++; // add 1 to the current value of cnt

cnt--; // subtract 1 from the current value of cnt

There is a prefix and postfix version of the increment and decrement operators. In the prefix application,

the object is either incremented (or decremented) by 1 before the object's value is accessed:

int tries = 0;

cout << "Are you ready for try #"

<< ++tries << "?\n";

In this example, tries is incremented by 1 before its value is printed. In the postfix application, the

object's value is first used in the expression, and then incremented (or decremented) by 1:

int tries = 1;

cout << "Are you ready for try #"

<< tries++ << "?\n";

In this example, the value of tries is printed before it is incremented by 1. In both examples, the value 1

is printed.

Each of the relational operators evaluates to either true or false. They consist of the following six operators:

== equality a == b

!= inequality a != b

< less than a < b

> greater than a > b

<= less than or equal a <= b

>= greater than or equal a >= b

Here is how we might use the equality operator to test the user's response:

bool usr_more = true;

char usr_rsp;

// ask the user if she wishes to continue

// read the response into usr_rsp

if (usr_rsp == 'N')

usr_more = false;

The if statement conditionally executes the statement following it if the expression within parentheses

evaluates to true. In this example,

usr_more is set to false if usr_rsp is equal to 'N'. If usr_rsp is

not equal to

'N', nothing is done. The reverse logic using the inequality operator looks like this:

if (usr_rsp != 'Y')

usr_more = false;

The problem with testing usr_rsp only for 'N' is that the user might enter a lowercase 'n'. We must

recognize both. One strategy is to add an

else clause:

if (usr_rsp == 'N')

usr_more = false;

else

if (usr_rsp == 'n')

usr_more = false;

If usr_rsp is equal to 'N', usr_more is set to false and nothing more is done. If it is not equal to 'N',

the else clause is evaluated. If usr_rsp is equal to 'n', usr_more is set to false. If usr_rsp is not

equal to either,

usr_more is not assigned.

A common beginner programmer error is to use the assignment operator for the equality test, as in the

following:

// oops this assigns usr_rsp the literal character 'N'

// and therefore always evaluates as true

if (usr_rsp = 'N')

// ...

The logical OR operator (||) provides an alternative way of testing the truth condition of multiple

expressions:

if (usr_rsp == 'N' || usr_rsp == 'n')

usr_more = false;

The logical OR operator evaluates as true if either of its expressions evaluates as true. The leftmost

expression is evaluated first. If it is true, the remaining expression is not evaluated. In our example,

usr_rsp is tested for equality with 'n' only if it is not equal to 'N'.

The logical

AND operator (&&) evaluates as true only if both its expressions evaluate as true. For example,

剩余250页未读，继续阅读

chaiwp03

粉丝: 0
资源: 7

快速掌握经典C++入门书：EssentialC++实战指南

快速掌握C++：EssentialC++精要

快速掌握C++编程精华：EssentialC++实战指南

快速掌握C++：Essential C++精要

Essentialc++ pdf版

Essentialc++对象模型

EssentialC++中文版(上)

EssentialC++源程序和课后习题答案.Stanley B. Lippman著

EssentialC++|例题代码|习题答案|错误校正|相关资料

EssentialC

斯坦福大学C语言基础讲义-EssentialC

最新资源