加速学习C++：现代方法，高效编程入门

需积分: 11 6 浏览量更新于2024-07-19 收藏 2.41MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

《加速C++：实践编程实例》(Accelerated C++, Practical Programming by Example) 是由Andrew Koenig和Barbara E. Moo合著的一本面向初学者的C++教程，出版于2000年，由Addison-Wesley出版社发行，ISBN号为0-201-70353-X。该书以其现代、高效的教学方法，帮助读者迅速掌握C++编程，跳过传统教学中的冗余步骤，直接从高级数据结构和算法开始学习，让学生能够更快地编写出强大且稳健的程序。本书的独特之处在于，它颠覆了传统的C++学习路径，从一开始就介绍诸如容器（如vector、list等）和算法（如排序、搜索等），这些是构建复杂程序的基础。通过实际问题驱动的学习，作者引导读者在实践中理解和运用这些概念，而不仅仅是理论讲解。第0章“入门”部分，主要涵盖了C++语言的基本元素，如注释、包含指令（#include）、main函数、控制结构（如花括号）、标准库的使用以及返回语句。这些章节旨在建立坚实的编程基础，让读者逐渐适应C++语言环境。第1章“处理字符串”，深入探讨输入操作，如何创建和格式化字符串，为后续处理文本数据打下基础。第2章“循环与计数”涉及解决问题的策略，如编写处理未知行数的程序，通过迭代实现一行一行的操作，并教授如何进行计数。这一章强调了循环结构在实际编程中的应用。第3章“处理批量数据”展示了如何计算学生成绩，引入更高级的方法如使用中位数替代平均值，以提高数据处理的灵活性和精确性。第4章“组织程序和数据”探讨了如何有效地组织代码逻辑，包括数据结构的选择和代码模块化的必要性。作者通过拆分和优化一个评分程序来展示这些技巧。最后一章“使用模板和STL”，深入讨论C++模板，这是C++标准模板库（STL）的核心，以及如何利用这些工具来简化代码并提高效率。《加速C++》以其实践导向的教学方式，不仅教会读者C++语言本身，而且注重培养他们的编程思维和解决问题的能力，使他们在短时间内就能写出高质量的C++代码。无论你是初学者还是想提升现有技能的开发者，这本书都是一本极具价值的学习资源。

资源详情

资源推荐

0.2 #include

In C++, many fundamental facilities, such as input-output, are part of the standard

library, rather than being part of the core language. This distinction is important because

the core language is always available to all C++ programs, but you must explicitly ask for

the parts of the standard library that you wish to use.

Programs ask for standard-library facilities by using #include directives. Such directives

normally appear at the beginning of a program. The only part of the standard library that

our program uses is input-output, which we request by writing

#include <iostream>

The name iostream suggests support for sequential, or stream, input-output, rather than

random-access or graphical input-output. Because the name iostream appears in an

#include directive and it is enclosed in angle brackets (< and >), it refers to a part of the

C++ library called a standard header.

The C++ standard does not tell us exactly what a standard header is, but it does define each

header's name and behavior. Including a standard header makes the associated library

facilities available to the program, but exactly how the implementation does so is its

concern, not ours.

0.3 The main function

A function is a piece of program that has a name, and that another part of the program can

call, or cause to run. Every C++ program must contain a function named main. When we

ask the C++ implementation to run a program, it does so by calling this function.

The main function is required to yield an integer as its result, the purpose of which is to tell

the implementation whether the program ran successfully. A zero value indicates success;

any other value means there was a problem. Accordingly, we begin by writing

int main()

to say that we are defining a function named main that returns a value of type int. Here,

int is the name that the core language uses to describe integers. The parentheses after

main enclose the parameters that our function receives from the implementation. In this

particular example, there are no parameters, so there is nothing between the parentheses.

We'll see how to use main's parameters in §10.4/179.

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.

剩余436页未读，继续阅读

albert92319

粉丝: 0
资源: 1

加速学习C++：现代方法，高效编程入门

Accelerated C++ 中文英文两版高清

Accelerated C++: Practical Programming by Example

Accelerated C++ 英文版

accelerated c++中文版pdf

迷宫游戏c++参考文献

The Best C plus plus Book

accelerate c++

visual c++并行编程实战

QWebEngineView如何启用硬件渲染？用C++方式

devc++制作五星红旗

如何在c++添加图片

opencv MeanShift算法优化稳定版c++

谷歌小恐龙c++代码

C++获取鼠标指针坐标

严重性 代码 说明 项目 文件 行 禁止显示状态 错误 C2338 THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS

使用c++实现流星雨

c++与sdl2让两个画面分图层分线程分别绘制

C++编写一个跑酷游戏

用c++编俄罗斯方块小游戏

用纯C++实现泡泡堂小游戏，提供代码示例

最新资源

严重性代码说明项目文件行禁止显示状态错误 C2338 THIS_COEFFICIENT_ACCESSOR_TAKING_ONE_ACCESS_IS_ONLY_FOR_EXPRESSIONS_ALLOWING_LINEAR_ACCESS