C++编程基础：理查德·霍尔特曼的指导

需积分: 10 153 浏览量更新于2024-07-18 收藏 8.8MB PDF 举报

"Fundamentals of C++ Programming"是Richard L. Halterman撰写的一本关于C++编程的基础教程。在《C++编程基础》中，作者Richard L. Halterman首先介绍了软件开发的背景。他讨论了软件的重要性和在现代社会中的应用，以及C++作为一门强大的编程语言的角色。他还探讨了用于C++开发的各种工具，包括编辑器、编译器和调试器，这些都是学习和实践C++编程所必需的。在第二章“编写C++程序”中，Halterman详细阐述了简单C++程序的基本结构。他讲解了如何创建、编译和运行一个基本的“Hello, World!”程序，并通过一系列变体展示了C++程序的不同形式。他还提供了一个适用于初学者的C++程序模板，帮助读者快速上手。第三章“值与变量”深入讨论了C++中的基本数据类型。Halterman解释了整数值（如int）的概念，以及变量和赋值操作。他还介绍了标识符的规则，以及扩展的整数类型（如long和short）。此外，他还涵盖了浮点数类型（如float和double）、常量、其他数值类型，以及字符和枚举类型。最后，他提到了C++11引入的`auto`关键字，这是一种自动推断变量类型的特性。第四章“表达式与算术运算”中，Halterman讨论了C++中的表达式，包括它们如何组合值并执行计算。他讲解了混合类型表达式，即不同数据类型之间的运算，并详细说明了运算符的优先级和关联性，这是理解和编写正确代码的关键。这些章节只是本书的一部分，全书可能还涵盖了更多C++的基础概念，如控制流程（条件语句和循环）、函数、类和对象、内存管理等。Halterman通过实例和练习来辅助教学，确保读者能够逐步掌握C++编程的基础知识。这本书对于想要系统学习C++编程的初学者来说是一份宝贵的资源。

1.2. DEVELOPMENT TOOLS 5

• Compilers. A compiler translates the source code to target code. The target code may be the machine

language for a particular platform or embedded device. The target code could be another source

language; for example, the earliest C

compiler translated C

into C, another higher-level language.

The resulting C code was then processed by a C compiler to produce an executable program. C

compilers today translate C

directly into machine language.

The complete set of build tools for C

includes a preprocessor, compiler, and linker:

– Preprocessor—adds to or modiﬁes the contents of the source ﬁle before the compiler begins

processing the code. We use the services of the preprocessor mainly to #include information

about library routines our programs use.

– Compiler—translates C

source code to machine code.

– Linker—combines the compiler-generated machine code with precompiled library code or

compiled code from other sources to make a complete executable program. Most compiled

code is incapable of running by itself and needs some additional machine code to make a

complete executable program. The missing machine code has been precompiled and stored in

a repository of code called a library. A program called a linker combines the programmer’s

compiled code and the library code to make a complete program.

We generally do not think about the preprocessor, compiler, and linker working as three separate

programs (although they do); the tools we use make it appear as only one process is taking place:

translating our source code to an executable program.

• Debuggers. A debugger allows a programmer to more easily trace a program’s execution in order

to locate and correct errors in the program’s implementation. With a debugger, a developer can

simultaneously run a program and see which line in the source code is responsible for the program’s

current actions. The programmer can watch the values of variables and other program elements to see

if their values change as expected. Debuggers are valuable for locating errors (also called bugs) and

repairing programs that contain errors. (See Section 4.6 for more information about programming

errors.)

• Proﬁlers. A proﬁler collects statistics about a program’s execution allowing developers to tune ap-

propriate parts of the program to improve its overall performance. A proﬁler indicates how many

times a portion of a program is executed during a particular run, and how long that portion takes to

execute. Proﬁlers also can be used for testing purposes to ensure all the code in a program is actually

being used somewhere during testing. This is known as coverage. It is common for software to fail

after its release because users exercise some part of the program that was not executed anytime during

testing. The main purpose of proﬁling is to ﬁnd the parts of a program that can be improved to make

the program run faster.

The programming components of the development process are illustrated in Figure 1.1.

Many developers use integrated development environments (IDEs). An IDE includes editors, debug-

gers, and other programming aids in one comprehensive program. Examples of IDEs for C

include

Microsoft’s Visual Studio 2015, the Eclipse Foundation’s Eclipse CDT, and Apple’s XCode.

Despite the plethora of tools (and tool vendors’ claims), the programming process for all but trivial

programs is not automatic. Good tools are valuable and certainly increase the productivity of developers,

but they cannot write software. There are no substitutes for sound logical thinking, creativity, common

sense, and, of course, programming experience.

1.3. LEARNING PROGRAMMING WITH C++ 6

1.3 Learning Programming with C++

Bjarne Stroustrup of AT&T Bell Labs created C

in the mid 1980s. C

is an extension of the programming

language C, a product of AT&T Bell Labs from the early 1970s. C was developed to write the Unix

operating system, and C is widely used for systems-level software and embedded systems development.

initially provided object-oriented programming features (see Chapter 13 and Chapter 14) and later

added generic programming capabilities. C

’s close relationship to C allows C

programs to utilize a

large collection of code developed in C.

is widely used in industry for commercial software development. It is an industrial strength pro-

gramming language used for developing complex systems in business, science, and engineering. Examples

of software written in C

include Microsoft Windows 8, Microsoft Ofﬁce, macOS, and Adobe Creative

Suite.

In order to meet the needs of commercial software development and accomplish all that it does, C

itself is complex. While experienced programmers can accomplish great things with C

, beginners some-

times have a difﬁcult time with it. Professional software developers enjoy the ﬂexible design options that

permits, but beginners need more structure and fewer options so they can master simpler concepts

before moving on to more complex ones.

This book does not attempt to cover all the facets of the C

programming language. Experienced

programmers should look elsewhere for books that cover C

in much more detail. The focus here is on

introducing programming techniques and developing good habits. To that end, our approach avoids some of

the more esoteric features of C

and concentrates on the programming basics that transfer directly to other

imperative programming languages such as Java, C#, and Python. We stick with the basics and explore

more advanced features of C

only when necessary to handle the problem at hand.

1.4 Exercises

1. What is a compiler?

2. How is compiled code different from source code?

3. What tool does a programmer use to produce C

source code?

4. What tool(s) does a programmer use to convert C

source code into executable machine code?

5. What does the linker do?

6. Does the linker deal with ﬁles containing source code or machine language code?

7. What does the preprocessor do to source code?

8. List several advantages developing software in a higher-level language has over developing software

in machine language.

9. How can an IDE improve a programmer’s productivity?

10. Name a popular C

IDE is used by programmers developing for Microsoft Windows.

11. Name a popular C

IDE is used by programmers developing for Apple macOS.

2.2. EDITING, COMPILING, AND RUNNING THE PROGRAM 8

source code before the compiler begins to process it. This process is done automatically and is

invisible to us.

Here we want to use an object from the iostream library, a collection precompiled C

code that

programs (like ours) can use. The iostream library contains elements that handle input and

output (I/O)—printing to the display, getting user input from the keyboard, and dealing with ﬁles.

One of the items used in Listing 2.1 (simple.cpp), std::cout, is not part of the C

language itself.

This item, along with other things related to input and output, were developed in C

, compiled, and

stored in the iostream library. The compiler needs to be aware of these iostream items so it

can compile our program. The #include directive speciﬁes a ﬁle, called a header, that contains

the speciﬁcations for the library code. The compiler checks how we use std::cout within our

code against its speciﬁcation in the <iostream> header to ensure that we are using the library code

correctly.

Most of the programs we write use this #include <iostream> directive, and some programs

we will write in the future will #include other headers as well.

• int main() {

This speciﬁes the real beginning of our program. Here we are declaring a function named main. All

programs must contain this function to be executable. Details about the meaning of int and

the parentheses will appear in later chapters. More general information about functions appear in

Chapter 8 and Chapter 9.

The opening curly brace at the end of the line marks the beginning of the body of a function. The

body of a function contains the statements the function is to execute.

• std::cout << "This is a simple C++ program!\n";

The body of our main function contains only one statement. This statement directs the executing

program to print the message This is a simple C++ program! on the screen. A statement is the

fundamental unit of execution in a C

program. Functions contain statements that the compiler

translates into executable machine language instructions. C

has a variety of different kinds of

statements, and the chapters that follow explore these various kinds of statements. All statements in

end with a semicolon (;). A more detailed explanation of this statement appears below.

• }

The closing curly brace marks the end of the body of a function. Both the open curly brace and close

curly brace are required for every function deﬁnition.

Note which lines in the program end with a semicolon (;) and which do not. Do

not put a semicolon after the #include preprocessor directive. Do not put a

semicolon on the line containing main, and do not put semicolons after the curly

braces.

2.2 Editing, Compiling, and Running the Program

programmers have two options for C

development environments. One option involves a command-

line environment with a collection of independent tools. The other option is to use an IDE (see Section 1.2)

which combines all the tools into a convenient package. Visual Studio is the dominant IDE on the Microsoft

2.3. VARIATIONS OF OUR SIMPLE PROGRAM 9

Windows platform, and Apple Mac developers often use the XCode IDE. Appendix A provides an overview

of how to use the Visual Studio 2015 IDE to develop a simple C

program.

The myriad of features and conﬁguration options in these powerful IDEs can be bewildering to those

learning how to program. In a command-line environment the programmer needs only type a few simple

commands into a console window to edit, compile, and execute programs. Some developers prefer the

simplicity and ﬂexibility of command-line build environments, especially for less complex projects.

One prominent command-line build system is the GNU Compiler Collection (http://gcc.gnu.

org), or GCC for short. The GCC C++ compiler, called g++, is one of most C

standards conforming

compilers available. The GCC C

compiler toolset is available for the Microsoft Windows, Apple Mac,

and Linux platforms, and it is a free, open-source software project with a world-wide development team.

Appendix B provides an overview of how to use the GCC C

compiler.

Visual Studio and XCode offer command line development options as well. Appendix B provides an

overview of the Visual Studio command line development process.

2.3 Variations of our simple program

Listing 2.2 (simple2.cpp) shows an alternative way of writing Listing 2.1 (simple.cpp).

Listing 2.2: simple2.cpp

#include <iostream>

using std::cout;

int main() {

cout << "This is a simple C++ program!\n";

}

The using directive in Listing 2.2 (simple2.cpp) allows us to use a shorter name for the std::cout

printing object. We can omit the std:: preﬁx and use the shorter name, cout. This directive is optional,

but if we omit it, we must use the longer name. The name std stands for “standard,” and the std preﬁx

indicates that cout is part of a collection of names called the standard namespace. The std namespace

holds names for all the standard C

types and functions that must be available to all standards-conforming

development environments. Components outside the standard library provided by third-party develop-

ers reside in their own separately-named namespaces. These include open-source projects and commercial

libraries.

Listing 2.3 (simple3.cpp) shows another way to use the shorter name for cout within a C

program.

Listing 2.3: simple3.cpp

#include <iostream>

using namespace std;

int main() {

cout << "This is a simple C++ program!\n";

}

While Listing 2.2 (simple2.cpp) made the name cout known to the compiler via its focused using di-

rective, Listing 2.3 (simple3.cpp) provides a blanket using directive that makes all names in the std

剩余745页未读，继续阅读

qq_42032704

粉丝: 0
资源: 2

C++编程基础：理查德·霍尔特曼的指导

C++编程基础教程：Richard L. Halterman的经典指南

C++编程入门：Haltermann的基础教程

C++编程基础：理查德·哈特曼的《编程基础》

C ++编程基础（Richard L. Halterman）Fundamentals of Programming C++ (Richard L. Halterman)

Fundamentals of Programming C ++(经典教程 Richard L. Halterman)

Fundamentals of Python Programming - Rick Halterman.pdf

JavaSE程序设计课件：L01-Fundamentals of Java Programming - 1.pdf

JavaSE程序设计课件：L01-Fundamentals of Java Programming - 2.pdf

[计算机科学经典著作].SAMS.-.Tricks.Of.The.Windows.Game.Programming.Gurus.-.Fundamentals.Of.2D.And.3D.Game.Programming.[eMule.ppcn.net].pdf

Charles.River.Media.Fundamentals.of.SVG.Programming.Concepts.to.Source.Code.eBook-DDU.chm

最新资源

Fundamentals of Programming C ++(经典教程　Richard L. Halterman)