Accelerated C++：实践编程指南

5星 · 超过95%的资源需积分: 50 5 浏览量更新于2024-07-22 2 收藏 1.68MB PDF 举报

"Accelerated C++ 是一本英文版的C++编程入门书籍，由Andrew Koenig和Barbara E. Moo合著，于2000年由Addison-Wesley出版，ISBN号为0-201-70353-X，共336页，内容涵盖C++的基础知识，并通过实例进行讲解。本书适合有一定英语基础的学习者阅读，通常被认为比中文翻译版更为精确和易懂。" 《Accelerated C++》是一本旨在快速教授C++编程实践的书籍，其内容结构清晰，逐步引导读者进入C++的世界。作者通过实例编程的方式，让初学者能够更直观地理解和掌握编程概念。在第一章"Getting started"中，介绍了编程的基本元素，包括注释、预处理指令`#include`、主函数`main()`、花括号的使用、标准库的输出操作、`return`语句以及更深入的探讨。这些都是编写任何C++程序的基础。第二章"Working with strings"涉及字符串的处理，讲解了如何输入字符串、在字符串周围添加边框（命名）以及相关的细节。第三章"Looping and counting"专注于循环和计数，通过解决具体问题来阐述循环结构，如按未知行数打印内容、逐行输出和计数方法，同时深入讲解了相关细节。第四章"Working with batches of data"讨论了批处理数据，如计算学生分数，以及如何使用中位数代替平均值来分析数据。这一章强调了组织计算和数据的重要性。第五章"Organizing programs and data"介绍了如何组织程序和数据结构，通过将评分程序进行分区和修订，展示了如何将这些概念应用于实际项目。第六章"Using sequential containers and analyzing strings"进一步探讨了序列容器的使用，如迭代器，以及如何用迭代器替换索引操作字符串。此外，还重新设计了数据结构，以适应更复杂的任务需求。这本书不仅适合初学者，也对有一定经验的程序员有价值，因为它提供了一种高效学习C++的方式，强调了实用的编程实践和良好的编程习惯。通过阅读和实践书中的例子，读者可以快速建立起坚实的C++编程基础。

0.5 Using the standard library for output

The first statement inside the braces does our program's real work:

std::cout << "Hello, world!" << std::endl;

This statement uses the standard library's output operator, <<, to write Hello,

world! on the standard output, and then to write the value of std::endl.

Preceding a name by std:: indicates that the name is part of a namespace named

std. A namespace is a collection of related names; the standard library uses std to

contain all the names that it defines. So, for example, the iostream standard header

defines the names cout and endl, and we refer to these names as std::cout and

std::endl.

The name std::cout refers to the standard output stream, which is whatever facility

the C++ implementation uses for ordinary output from programs. In a typical C++

implementation under a windowing operating system, std::cout will denote the

window that the implementation associates with the program while it is running. Under

such a system, the output written to std::cout will appear in the associated window.

Writing the value of std::endl ends the current line of output, so that if this program

were to produce any more output, that output would appear on a new line.

0.6 The return statement

A return statement, such as

return 0;

ends execution of the function in which it appears, and passes the value that appears

between the return and the semicolon (0 in this example) back to the program that

called the function that is returning. The value that is returned must have a type that is

appropriate for the type that the function says it will return. In the case of main, the

return type is int and the program to which main returns is the C++ implementation

itself. Therefore, a return from main must include an integer-valued expression, which

is passed back to the implementation.

Of course, there may be more than one point at which it might make sense to terminate

a program; such a program may have more than one return statement. If the

definition of a function promises that the function returns a value of a particular type,

then every return statement in the function must return a value of an appropriate

type.

0.7 A slightly deeper look

This program uses two additional concepts that permeate C++: expressions and scope.

We will have much more to say about these concepts as this book progresses, but it is

worthwhile to begin with some of the basics here.

An expression asks the implementation to compute something. The computation yields

a result, and may also have side effects-that is, it may affect the state of the program

or the implementation in ways that are not directly part of the result. For example, 3+4

is an expression that yields 7 as its result, and has no side effects, and

std::cout << "Hello, world!" << std::endl

is an expression that, as its side effect, writes Hello, world! on the standard output

stream and ends the current line.

An expression contains operators and operands, both of which can take on many forms.

In our Hello, world! expression, the two << symbols are operators, and

std::cout, "Hello, world! " and std::endl are operands.

Every operand has a type. We shall have much more to say about types, but

essentially, a type denotes a data structure and the meanings of operations that make

sense for that data structure. The effect of an operator depends on the types of its

operands.

Types often have names. For example, the core language defines int as the name of a

type that represents integers, and the library defines std::ostream as the type that

provides stream-based output. In our program, std::cout has type std::ostream.

The << operator takes two operands, and yet we have written two << operators and

three operands. How can this be? The answer is that << is left-associative, which,

loosely speaking, means that when << appears twice or more in the same expression,

each << will use as much of the expression as it can for its left operand, and as little of

it as it can for its right operand. In our example, the first << operator has "Hello,

world! " as its right operand and std::cout as its left operand, and the second <<

operator has std::endl as its right operand and std::cout << "Hello, world!

" as its left operand. If we use parentheses to clarify the relationship between operands

and operators, we see that our output expression is equivalent to

(std::cout << "Hello, world!") << std::endl

Each << behaves in a way that depends on the types of its operands. The first << has

std::cout, which has type std::ostream, as its left operand. Its right operand is a

string literal, which has a mysterious type that we shall not even discuss until

§10.2/176. With those operand types, << writes its right operand's characters onto the

stream that its left operand denotes, and its result is its left operand.

The left operand of the second << is therefore an expression that yields std::cout,

which has type std::ostream; the right operand is std::endl, which is a

manipulator. The key property of manipulators is that writing a manipulator on a

stream manipulates the stream, by doing something other than just writing characters

to it. When the left operand of << has type std::ostream and the right operand is a

manipulator, << does whatever the manipulator says to do to the given stream, and

returns the stream as its result. In the case of std::endl, that action is to end the

current line of output.

The entire expression therefore yields std::cout as its value, and, as a side effect, it

writes Hello, world! on the standard output stream and ends the output line. When

we follow the expression by a semicolon, we are asking the implementation to discard

the value-which action is appropriate, because we are interested only in the side effects.

The scope of a name is the part of a program in which that name has its meaning. C++

has several different kinds of scopes, two of which we have seen in this program.

The first scope that we used is a namespace, which, as we've just seen, is a collection of

related names. The standard library defines all of its names in a namespace named std,

so that it can avoid conflicts with names that we might define for ourselves-as long as

we are not so foolish as to try to define std. When we use a name from the standard

library, we must specify that the name we want is the one from the library; for example,

std::cout means cout as defined in the namespace named std.

The name std::cout is a qualified name, which uses the :: operator. This operator

is also known as the scope operator. To the left of the :: is the (possibly qualified)

name of a scope, which in the case of std::cout is the namespace named std. To the

right of the :: is a name that is defined in the scope named on the left. Thus,

std::cout means "the name cout that is in the (namespace) scope std."

Curly braces form another kind of scope. The body of main-and the body of every

function-is itself a scope. This fact is not too interesting in such a small program, but it

will be relevant to almost every other function we write.

0.8 Details

Although the program we've written is simple, we've covered a lot of ground in this

chapter. We intend to build on what we've introduced here, so it is important for you to

be sure that you understand this chapter fully before you continue.

To help you do so, this chapter-and every chapter except Chapter 16-ends with a section

called Details and a set of exercises. The Details sections summarize and occasionally

expand on the information in the text. It is worth looking at each Details section as a

reminder of the ideas that the chapter introduced.

Program structure: C++ programs are usually in free form, meaning that spaces are

required only when they keep adjacent symbols from running together. In particular,

newlines (i.e., the way in which the implementation represents the change from one line

of the program to the next) are just another kind of space, and usually have no

additional special meaning. Where you choose to put spaces in a program can make it

much easier-or harder-to read. Programs are normally indented to improve readability.

There are three entities that are not free-form:

string literals

characters enclosed in double quotes; may not span lines

#include name

must appear on a line by themselves (except for comments)

// comments

// followed by anything; ends at the end of the current line

A comment that begins with /* is free-form; it ends with the first subsequent */ and

can span multiple lines.

Types define data structures and operations on those data structures. C++ has two

kinds of types: those built into the core language, such as int, and those that are

defined outside the core language, such as std::ostream.

Namespaces are a mechanism for grouping related names. Names from the standard

library are defined in the namespace called std.

String literals begin and end with double quotes ("); each string literal must appear

entirely on one line of the program. Some characters in string literals have special

meaning when preceded by a backslash (\):

\n newline character

\t tab character

\b backspace character

\" treats this symbol as part of the string rather than as the string terminator

\' same meaning as ' in string literals, for consistency with character literals

(§1.2/14)

\\ includes a \ in the string, treating the next character as an ordinary character

We'll see more about string literals in §10.2/176 and §A.2.1.3/302.

Definitions and headers: Every name that a C++ program uses must have a

corresponding definition. The standard library defines its names in headers, which

programs access through #include. Names must be defined before they are used;

hence, a #include must precede the use of any name from that header. The

<iostream> header defines the library's input-output facilities.

The main function: Every C++ program must define exactly one function, named

main, that returns an int. The implementation runs the program by calling main. A

zero return from main indicates success; a nonzero return indicates failure. In general,

functions must include at least one return statement and are not permitted to fall off

the end of the function. The main function is special: It may omit the return; if it does

so, the implementation will assume a zero return value. However, explicitly including a

return from main is good practice.

Braces and semicolons: These inconspicuous symbols are important in C++ programs.

They are easy to overlook because they are small, and they are important because

forgetting one typically evokes compiler diagnostic messages that may be hard to

understand.

A sequence of zero or more statements enclosed in braces is a statement, called a

block, which is a request to execute the constituent statements in the order in which

they appear. The body of a function must be enclosed in braces, even if it is only a

single statement. The statements between a pair of matching braces constitute a scope.

An expression followed by a semicolon is a statement, called an expression statement,

which is a request to execute the expression for its side effects and discard its result.

The expression is optional; omitting it results in a null statement, which has no effect.

Output: Evaluating std::cout << e writes the value of e on the standard-output

stream, and yields std::cout, which has type ostream, as its value in order to allow

chained output operations.

Exercises

0-0. Compile and run the Hello, world! program.

0-1. What does the following statement do?

3 + 4;

0-2. Write a program that, when run, writes

This (") is a quote, and this (\) is a backslash.

0-3. The string literal "\t" represents a tab character; different C++ implementations

剩余411页未读，继续阅读

zzcc12zy

粉丝: 1
资源: 1

Accelerated C++：实践编程指南

Accelerated.C++（英文版）

visual c++6.0英文版

Accelerated C++英文版

Accelerated C++ 英文版

accelerated c++ 英文版及源码

Accelerated C++英文版chm格式

Accelerated C++ 进阶版

Accelerated C++ 中文版

非常全面的c_c++教程（英文版）

visual c++ 6.0英文版

最新资源