Accelerated C++编程实践指南

需积分: 9 36 浏览量更新于2024-07-18 收藏 1.7MB PDF 举报

"Accelerated C++ Programming - 入门级C++教程" 《Accelerated C++》是一本由Andrew Koenig和Barbara E. Moo合著的C++编程书籍，旨在提供一种快速学习C++的方法，通过实践编程例子来引导初学者。这本书以其简洁和实用的特性受到赞誉，适合程序员入门C++语言。本书分为多个章节，逐步介绍C++的基础知识和编程技巧：第一章"Getting started"（开始）：这一章介绍了C++编程的基本元素，如注释、`#include`预处理器指令、`main`函数、花括号的作用、使用标准库进行输出以及`return`语句。这些是构建任何C++程序的基础。第二章"Working with strings"（操作字符串）：作者讲解了如何处理文本输入，以及如何围绕一个名称添加框架。这部分内容涉及到C++中的字符串处理和输入/输出操作，这是许多编程任务的核心。第三章"Looping and counting"（循环与计数）：本章关注循环结构，包括解决实际问题的整体策略，编写不确定行数的代码，以及如何写出一行内容。同时，还介绍了计数机制，这是程序控制流程的关键部分。第四章"Working with batches of data"（批量数据处理）：在这个章节中，读者将学习如何处理学生成绩等批量数据，以及如何使用中位数代替平均值进行统计分析。这展示了如何组织和操作数据集，这对于数据分析和算法设计至关重要。第五章"Organizing programs and data"（组织程序和数据）：这一章探讨了如何更好地组织计算和数据结构。通过将评分程序划分为更小的部分，作者展示了模块化编程的重要性，并给出了改进后的评分程序示例。理解程序结构和数据结构的组织方式对于提高代码的可读性和可维护性至关重要。每个章节都包含“Details”部分，这些部分深入探讨了特定主题，提供了更多关于C++语法和技术的细节，帮助读者深入理解概念并避免常见陷阱。《Accelerated C++》是一本以实践为导向的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页未读，继续阅读

qq_42317718

粉丝: 0
资源: 1

Accelerated C++编程实践指南

Accelerated C++ PDF 中英文版

Accelerated C++ Practical Programming by Example

Accelerated C++: Practical Programming by Example(解密PDF)

Accelerated C++: Practical Programming by Example

Accelerated C++ : Practical Programming by Example、C++ 快速入门 —— 跟着实例学编程

Accelerated C++

深入C++ Accelerated C++

Accelerated C++.chm

Addison Wesley - Accelerated C++

Addison.Wesley.Accelerated.C++.Practical.Programming.by.Example

最新资源