C++编程抽象：斯坦福CS106B课程教材

5星 · 超过95%的资源需积分: 36 153 浏览量更新于2024-08-02 收藏 8.04MB PDF 举报

“编程抽象在C++中的应用，斯坦福大学CS106B教材，由Julie Zelenski编辑。包含完整的CS106B库文件和所有示例。” 《编程抽象在C++中》是由Eric S. Roberts和Julie Zelenski合著的一本课程读物，其发展历程与C++语言的起源有相似之处。最初，这本书基于Eric Roberts的《编程抽象在C中》（Addison-Wesley,1998年），而在2002-03年间，Julie Zelenski对其进行了更新，以适应C++编程语言的教学，这是当时CS106B和CS106X课程所采用的语言。尽管修订后的文本在初期表现得相当不错，但近年来，CS106B和CS106X课程的结构已经发展变化，不再与书中的组织结构完全匹配。因此，作者们正在着手重写这本书，目的是使其既可用作教程，也可作为参考书籍。这个过程需要大量的时间，并且在更新过程中可能会出现一些问题。然而，作者们相信，CS106B和CS106X课程中的内容极其引人入胜，足以应对一段时间的不稳定性，并最终将带来一本更优秀的教材。这本教材的目标是教授学生如何在C++中进行编程抽象，这是一个核心的计算机科学概念。编程抽象是指通过创建抽象数据类型和封装来简化复杂性的过程，这在C++中尤为重要，因为C++支持面向对象编程，允许程序员创建类和对象，以实现代码的模块化和可复用性。在课程中，学生将学习C++的基础知识，如变量、控制流、函数和数组，然后逐步深入到更复杂的主题，如类、对象、继承和多态性。此外，还将涵盖C++标准模板库（STL），包括容器（如vector和list）、算法和迭代器，这些都是现代C++编程中不可或缺的部分。通过这门课程，学生不仅会掌握C++语言的基本语法，还会了解到如何设计和实现高效的程序，以及如何使用抽象来解决实际问题。同时，书中可能还会讨论错误处理、调试技巧和性能优化等实践技能，这些都是成为一名专业软件开发者所必需的。在更新的过程中，作者们会不断改进教材，确保它能够反映出最新的编程最佳实践和技术趋势。随着C++语言的发展，这本书也将与时俱进，为学生提供最前沿的教育体验。《编程抽象在C++中》是一本旨在帮助学生掌握C++编程语言精髓的教材，它强调了抽象思维在编程中的重要性，旨在培养出能够编写清晰、可维护和高效代码的程序员。通过学习这本书，学生将具备在各种项目中运用C++解决问题的能力，并为未来进一步的计算机科学学习打下坚实基础。

An Overview of C++ – 8 –

The main program

Every C++ program must contain a function with the name

main. This function specifies

the starting point for the computation and is called when the program starts up. When

main has finished its work and returns, execution of the program ends.

The first three statements of the

main function in the powertab.cpp program are

sending information to the cout stream to display output on the screen. A few useful

notes about streams are included in the section on “Simple input and output” later in this

chapter and more features are explored in detail in Chapter 3. At this point, you need to

have an informal sense of how to display output to understand any programming example

that communicates results to the user. In its simplest form, you use the insertion operator

<< to put information into the output stream cout. If you insert a string enclosed in

double quotes, it will display that string on the console. You must indicate explicitly that

you want to move on to the next line by inserting the stream manipulator endl. Thus,

the first three lines in main display the header for the table.

The rest of the function

main consists of the following code, which is responsible for

displaying the table itself:

for (int n = LOWER_LIMIT; n <= UPPER_LIMIT; n++) {

cout << setw(3) << n << " |" ;

cout << setw(4) << RaiseIntToPower(n, 2) << " |" ;

cout << setw(5) << RaiseIntToPower(2, n) << endl;

}

This code is an example a for loop, which is used to specify repetition. In this case, the

for statement indicates that the body of the loop should be repeated for each of the

values of n from LOWER_LIMIT to UPPER_LIMIT. A section on the detailed structure of

the for loop appears later in the chapter, but the example shown here represents a

common idiomatic pattern that you can use to count between any specified limits.

The body of the loop illustrates an important new feature: the ability to include values

as part of the output display. Rather than just displaying fixed strings, we can display

numeric values and computed results. We can also use stream manipulators to format the

output. Let’s examine the first statement in the body of the loop:

cout << setw(3) << n << " |" ;

This line will display the current value of the variable n followed by a string

containing a space and a vertical bar. The setw(3) that is inserted into the stream just

before n indicates that the stream should format the next value in a field that is three

characters wide. Similarly, the next statement prints the formatted result taken from the

expression RaiseIntToPower(n, 2). Obtaining the value of the expression requires

making a call on the RaiseIntToPower function, which is discussed in the following

section. The value that RaiseIntToPower returns is displayed as part of the output. So

is the result of the call to RaiseIntToPower(2, n), which supplies the value for the third

column in the table.

The last statement in

main is

return 0;

which indicates that the function result is 0. The return value from the main function is

used to communicate the success or failure of the entire program. By convention, a result

of 0 indicates success.

An Overview of C++ – 9 –

Function definitions

Because large programs are difficult to understand in their entirety, most programs are

broken down into several smaller functions, each of which is easier to understand. In the

powertab.cpp program, the function RaiseIntToPower is responsible for raising an

integer to a power—an operation that is not built into C++ and must therefore be defined

explicitly.

The first line of

RaiseIntToPower is the variable declaration

int result;

which introduces a new variable named result capable of holding values of type int,

the standard type used to represent integers. The syntax of variable declarations is

discussed in more detail in the section on “Variables, values, and types” later in this

chapter. For now, all you need to know is that this declaration creates space for an

integer variable that you can then use in the body of the function.

The next line in the body of

RaiseIntToPower is

result = 1;

This statement is a simple example of an assignment statement, which sets the variable

on the left of the equal sign to the value of the expression on the right. In this case, the

statement sets the variable result to the constant 1. The next statement in the function is

a for loop that executes its body k times. The repeated code consists of the line

result *= n;

which is a C++ shorthand for the English sentence “Multiply result by n.” Because the

function initializes the value of result to 1 and then multiplies result by n a total of k

times, the variable result ends up with the value n

The last statement in

RaiseIntToPower is

return result;

which indicates that the function should return result as the value of the function.

1.3 Variables, values, and types

One of the fundamental characteristics of programs is that they manipulate data. To do

so, programs must be able to store data as part of their operation. Moreover, programs

today work with many different kinds of data, including numbers and text, along with

many more sophisticated data structures, such as those introduced in Part 3 of this book.

Learning how to store data of various types is an important part of mastering the basics of

any language, including C++.

Variables

Data values in a program are usually stored in variables. In C++, if you want to use a

variable to hold some information, you must declare that variable before you use it.

Declaring a variable establishes the following properties:

• Name. Every variable has a name, which is formed according to the rules described in

the section entitled “Naming conventions” later in this chapter. You use the name in

the program to refer to the variable and the value it contains.

An Overview of C++ – 10 –

• Type. Each variable in a C++ program is constrained to hold values of a particular

data type. C++ includes several predefined types and also allows you to define new

types of your own, as discussed in Chapter 2.

• Lifetime. Depending on how they are declared, some variables persist throughout the

entire program, while others are created and destroyed dynamically as the program

moves through various levels of function call.

• Scope. The declaration of a variable also controls what parts of the program have

access to the variable, which is called its scope.

The standard syntax for declaring a variable is

type namelist;

where type indicates the data type and namelist is a list of variable names separated by

commas. For example, the function RaiseIntToPower in the powertab.cpp program

contains the line

int result;

which declares the variable result to be of type int.

In C++, the initial contents of a variable are undefined. If you want a variable to have

a particular initial value, you need to initialize it explicitly. One approach is to use an

assignment statement in the body of the function to assign a value to each variable before

you use it. You can, however, include initial values directly in a declaration by writing

an equal sign and a value after a variable name. Thus, the declaration

int result = 0;

is a shorthand for the following code, in which the declaration and assignment are

separate:

int result;

result = 0;

An initial value specified as part of a declaration is called an initializer.

Naming conventions

The names used for variables, functions, types, constants, and so forth are collectively

known as identifiers. In C++, the rules for identifier formation are

1. The name must start with a letter or the underscore character (

_).

2. All other characters in the name must be letters, digits, or the underscore. No spaces

or other special characters are permitted in names.

3. The name must not be one of the reserved keywords listed in Table 1-1

Uppercase and lowercase letters appearing in an identifier are considered to be different.

Thus, the name

ABC is not the same as the name abc. Identifiers can be of any length, but

C++ compilers are not required to consider any more than the first 31 characters in

determining whether two names are identical. Implementations may impose additional

restrictions on identifiers that are shared between modules.

You can improve your programming style by adopting conventions for identifiers that

help readers identify their function. In this text, names of variables and data types begin

An Overview of C++ – 11 –

Table 1-1 C++ reserved keywords

asm do inline short typeid

auto double int signed typename

bool dynamic_cast long sizeof union

break else mutable static unsigned

case enum namespace static_cast using

catch explicit new struct virtual

char extern operator switch void

class false private template volatile

const float protected this wchar_t

const_cast for public throw while

continue friend register true

default goto reinterpret_cast try

delete if return typedef

with a lowercase letter, such as n1, total, or string. By contrast, function names, such

as RaiseIntToPower, usually begin with an uppercase letter. Moreover, whenever a

name consists of several English words run together, the first letter in each word after the

first is capitalized to make the name easier to read. By tradition, constant names, such as

LOWER_LIMIT are written entirely in uppercase, with underscores between the words.

Local and global variables

Most variables are declared with the body of a function. Such variables are called local

variables. The scope of a local variable extends to the end of the block in which it is

declared. The lifetime of a local variable is the time during which that function is active.

When the function is called, space for each local variable is allocated for the duration of

that function call. When the function returns, all its local variables disappear.

If a variable declaration appears outside any function definition, that declaration

introduces a global variable. The scope of a global variable is the remainder of the file

in which it is declared. Its lifetime continues throughout the entire execution of a

program. Global variables are therefore able to store values that persist across function

calls. Although they have important applications, global variables can easily be

overused. Because global variables can be manipulated by many different functions, it is

harder to keep those functions from interfering with each other. Because of these

dangers, global variables are used infrequently in this text.

The concept of a data type

One of the reasons C++ requires all variables to be declared is that doing so constrains

their contents to values of a particular data type. From a formal perspective, a data type

is defined by two properties: a domain, which is the set of values that belong to that type,

and a set of operations, which defines the behavior of that type. For example, the domain

of the type

int includes all integers (. . . –2, –1, 0, 1, 2 . . .) up to the limits established by

the hardware of the machine. The set of operations applicable to values of type int

includes, for example, the standard arithmetic operations like addition and multiplication.

Other types have a different domain and set of operations.

As you will learn in Chapter 2, much of the power of higher-level languages like C++

comes from the fact that you can define new data types from existing ones. To get that

process started, C++ includes several fundamental types that are defined as part of the

language (or, in the case of

string, as part of the standard C++ libraries). These types,

which act as the building blocks for the type system as a whole, are called atomic types.

These predefined types are grouped into four categories—integer, floating-point, text, and

Boolean—which are discussed in the sections that follow.

An Overview of C++ – 12 –

Integer types

Although the concept of an integer seems like a simple one, C++ actually includes several

different data types for representing integer values. In most cases, all you need to know

is the type

int, which corresponds to the standard representation of an integer on the

computer system you are using. In certain cases, however, you need to be more careful.

Like all data, values of type int are stored internally in storage units that have a limited

capacity. Those values therefore have a maximum size, which limits the range of

integers you can use. To get around this problem, C++ defines three integer types—

short, int, and long—distinguished from each other by the size of their domains.

Unfortunately, the language definition for C++ does not specify an exact range for

these three types. As a result, the range for the different integer types depends on the

machine and the compiler you’re using. On many personal computers, the maximum

value of type

int is 32,767, which is rather small by computational standards. If you

wanted, for example, to perform a calculation involving the number of seconds in a year,

you could not use type int on those machines, because that value (31,536,000) is

considerably larger than the largest available value of type int. The only properties you

can rely on are the following:

• The internal size of an integer cannot decrease as you move from short to int to

long. A compiler designer for C++ could, for example, decide to make short and int

the same size but could not make int smaller than short.

• The maximum value of type

int must be at least 32,767 (2

–1).

• The maximum value of type

long must be at least 2,147,483,647 (2

–1).

The designers of C++ could have chosen to define the allowable range of type int

more precisely. For example, they could have declared—as the designers of Java did—

that the maximum value of type int would be 2

–1 on every machine. Had they done

so, it would be easier to move a program from one system to another and have it behave

in the same way. The ability to move a program between different machines is called

portability, which is an important consideration in the design of a programming

language.

In C++, each of the integer types

int, long, and short may be preceded by the

keyword unsigned. Adding unsigned creates a new data type in which only

nonnegative values are allowed. Because unsigned variables do not need to represent

negative values, declaring a variable to be one of the unsigned types allows it to hold

twice as many positive values. For example, if the maximum value of type int is 32,767,

the maximum value of type unsigned int will be 65,535. C++ allows the type unsigned

int to be abbreviated to unsigned, and most programmers who use this type tend to

follow this practice. Sometimes variables intended to store sizes are declared as

unsigned, because a size will always be nonnegative.

An integer constant is ordinarily written as a string of digits representing a number in

base 10. If the number begins with the digit 0, however, the compiler interprets the value

as an octal (base 8) integer. Thus, the constant

040 is taken to be in octal and represents

the decimal number 32. If you prefix a numeric constant with the characters 0x, the

compiler interprets that number as hexadecimal (base 16). Thus, the constant 0xFF is

equivalent to the decimal constant 255. You can explicitly indicate that an integer

constant is of type long by adding the letter L at the end of the digit string. Thus, the

constant 0L is equal to 0, but the value is explicitly of type long. Similarly, if you use the

letter U as a suffix, the constant is taken to be unsigned.

剩余681页未读，继续阅读

dassio

粉丝: 4
资源: 8

C++编程抽象：斯坦福CS106B课程教材

programming abstractions in C++

C++编程语言，经典的C++教程（英文版）

斯坦福大学c++与数据结构教程Programming Abstractions in C++

C PLUS PLUS

C plus plus

java native

C&W算法用pytorch实现

? 5 ? /etc/apparmor.d/local/usr.bin.ping in /etc/apparmor.d/local/usr.bin.ping ?AppArmor?????:????"abstractions/lightdm"

elasticsearch client

10.1. What is IoC? Describe the implementation of IoC using pseudo-Code. 10.4. Describe the DIP in your own words. What might happen if a designer depends too heavily on concretions?

最新资源