C++编程抽象与多范式探索

需积分: 36 11 浏览量更新于2024-07-23 收藏 8.04MB PDF 举报

"《在C++编程抽象》是由Eric S. Roberts和Julie Zelenski合著的一本课程读物，它具有丰富的历史背景，反映了C++语言的发展历程。这本书最初基于Eric Roberts的C语言教科书《Programming Abstractions in C》，在2002-03年被Julie Zelenski更新以适应C++编程语言，用于CS106B和CS106X课程。随着时间的推移，这两个课程的结构已经发生了变化，不再与书中的组织结构完全对应，因此目前正在进行重写，以使其成为学生既可作为教程又可作为参考的资源。尽管在更新过程中可能会遇到一些问题，但作者们相信课程的内容极具吸引力，足以应对一段时间的不稳定，并最终会形成一个更优秀的教材。" 《在C++编程抽象》这本书的核心内容涉及以下几个关键知识点： 1. **面向对象编程**：C++是一种支持面向对象编程（OOP）的语言，它允许程序员通过类、对象、继承、封装和多态等概念来设计和实现软件。OOP提供了一种组织代码的方式，使得程序更加模块化和易于维护。 2. **编程范式**：书中强调了掌握多种编程范式的重要性，包括函数式编程。函数式编程如LISP，强调使用函数作为基本构建块，避免改变状态和可变数据。了解并能灵活运用不同编程范式，可以让程序员根据任务需求选择最适合的解决方案。 3. **C++基础**：本书不仅覆盖了C++的基础知识，如变量、控制流、函数、数组和指针，还深入介绍了C++特有的特性，如模板、异常处理和STL（标准模板库）。 4. **抽象**：编程抽象是将复杂问题简化为更易管理的部分的过程，是C++编程中的重要概念。书中会介绍如何使用抽象来设计和实现复杂的系统，以及如何利用C++的构造（如类和接口）来实现这一目标。 5. **C++标准库**：C++标准库提供了大量预先编写好的函数和类，如容器、算法和输入/输出流。学习如何有效利用这些库可以提高代码效率和可读性。 6. **编程实践**：书中可能涵盖了良好的编程实践，如代码风格、调试技巧、错误处理和测试方法，这些都是成为一名优秀C++程序员所必需的技能。 7. **课程结构与教学方法**：随着CS106B和CS106X课程的发展，这本书的结构也在不断调整，以更好地匹配课程内容。这表明教育者们致力于保持课程内容与最新编程实践的同步，以确保学生能够学习到最实用的知识。《在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页未读，继续阅读

gilya

粉丝: 2
资源: 63

C++编程抽象与多范式探索

c语言抽象编程代码

C++编程思想（数据抽象）

C++ 接口（抽象类）

C-System-Programming-Cookbook:Packt出版的《 C ++系统编程手册》

8051混合编程（c语言+汇编）

C + +编程思想 c++的编程思想

《C&C++编程思想》

VisualC++系统编程选择题及答案解析

BjarneStroustrupc11:书中的源代码C ++编程语言c ++ 11-C language program source code

C语言+数据结构课程设计.zip

最新资源