C++入门指南：从基础到高级特性

需积分: 9 183 浏览量更新于2024-07-20 收藏 7.06MB PDF 举报

《初级C++入门指南》是一本面向初学者的C++教程，由Apress出版社编撰，旨在帮助读者逐步掌握C++编程语言的基础概念和核心技能。本书结构清晰，分为多个章节，便于学习者按照循序渐进的方式深入理解和实践。在本书的开端，提供了作者和技术评审者的介绍，为读者展示作者的专业背景和评审者的技术权威性。接下来的章节涵盖了C++编程的各个方面： 1. **基本理念** (Chapter 1)：首先介绍C++编程语言的基础理念，包括其历史、特点以及与其他编程语言的区别，帮助读者建立起对C++语言的整体认识。 2. **数据类型基础** (Chapter 2)：详细讲解了C++中的基本数据类型，如整型、浮点型、字符型等，以及它们的存储方式和操作规则。 3. **处理基础数据类型** (Chapter 3)：进一步探讨如何有效地操作和管理这些数据类型，涉及变量声明、运算符使用等内容。 4. **决策逻辑** (Chapter 4)：介绍了条件语句（if-else）、switch-case等控制结构，让读者理解如何根据特定条件执行不同的代码块。 5. **数组与循环** (Chapter 5)：讲解数组的定义、初始化以及循环结构（for、while等），帮助构建重复执行的代码逻辑。 6. **指针与引用** (Chapter 6)：深入理解指针和引用的概念，这两个概念是C++中非常关键的特性，对于内存管理和函数参数传递至关重要。 7. **字符串处理** (Chapter 7)：介绍了字符串类型、操作符以及常用字符串处理函数，如查找、替换等。 8. **函数定义** (Chapter 8)：讲解如何编写和调用函数，包括函数原型、参数传递和返回值，这对于模块化编程至关重要。 9. **lambda表达式** (Chapter 9)：讨论了C++11引入的lambda表达式，这是一种简洁的匿名函数定义方式，用于实现回调和函数对象。 10. **程序文件与预处理指令** (Chapter 10)：涉及头文件的使用、宏定义和条件编译，提高代码的可维护性和复用性。 11. **自定义数据类型** (Chapter 11)：讲解类和对象的概念，以及如何创建自己的数据类型来封装复杂的数据结构。 12. **运算符重载** (Chapter 12)：解释如何根据需要扩展C++内置运算符的行为，实现用户自定义的操作。 13. **继承与多态** (Chapter 13 & 14)：深入讲解面向对象编程的核心特性，包括继承、派生和多态，以及如何利用它们设计灵活的软件架构。 14. **运行时错误与异常处理** (Chapter 15)：讨论如何识别和处理程序运行过程中的错误和异常，确保程序的健壮性。 15. **模板类** (Chapter 16)：介绍模板作为C++的强大工具，它允许程序员编写通用的代码，适用于多种数据类型。 16. **文件输入与输出** (Chapter 17)：讲解文件操作，包括文件的打开、读写和关闭，以及如何处理文件I/O操作可能出现的问题。最后，本书还附有索引，方便读者查阅和回顾已经学习的内容。《初级C++入门指南》提供了全面且实用的学习路径，适合初学者系统地掌握C++编程语言。

CHAPTER 1 ■ BASIC IDEAS

This is called decimal notation because it’s built around powers of 10. We also say that we are representing numbers

to base 10 here because each digit position is a power of 10. Representing numbers in this way is very handy for beings

with ten fingers and/or ten toes, or indeed ten of any kind of appendage that can be used for counting. Your PC is rather

less handy, being built mainly of switches that are either on or off. Your PC is OK for counting in twos, but not spectacular

at counting in tens. I’m sure you’re aware that this is why your computer represents numbers using base 2, rather than

base 10. Representing numbers using base 2 is called the binary system of counting. Numbers in base 10 have digits that

can be from 0 to 9. In general, for numbers in an arbitrary base, n, the digit in each position in a number can be from 0 to

n-1. Thus binary digits can only be 0 or 1. A binary number such as 1101 breaks down like this:

1 × 2

+ 1 × 2

+ 0 × 2

+ 1 × 2

, which is 1 × 2 × 2 × 2 + 1 × 2 × 2 + 0 × 2 + 1

This is 13 in the decimal system. In Table 1-1, you can see the decimal equivalents of all the numbers you can

represent using eight binary digits, more commonly known as bits.

Table 1-1. Decimal Equivalents of 8-bit Binary Values

Binary Decimal Binary Decimal

0000 0000 0 1000 0000 128

0000 0001 1 1000 0001 129

0000 0010 2 1000 0010 130

. . . . . . . . . . . .

0001 0000 16 1001 0000 144

0001 0001 17 1001 0001 145

. . . . . . . . . . . .

0111 1100 124 1111 1100 252

0111 1101 125 1111 1101 253

0111 1110 126 1111 1110 254

0111 1111 127 1111 1111 255

0001 1101

0010 1011

0100 1000

Binary Decimal

carries

Figure 1-3. Adding binary values

Using the first seven bits, you can represent positive numbers from 0 to 127, which is a total of 128 different

numbers. Using all eight bits, you get 256 or 2

numbers. In general, if you have n bits available, you can represent 2

integers, with positive values from 0 to 2

–1.

Adding binary numbers inside your computer is a piece of cake, because the “carry” from adding corresponding

digits can only be 0 or 1. This means that very simple circuitry can handle the process. Figure 1-3 shows how the

addition of two 8-bit binary values would work.

CHAPTER 1 ■ BASIC IDEAS

Because a hexadecimal digit corresponds to four binary digits, you can represent any binary number in

hexadecimal simply by taking groups of four binary digits starting from the right, and writing the equivalent

hexadecimal digit for each group. Look at the following binary number:

1111 0101 1011 1001 1110 0001

Taking each group of four bits and replacing it with the corresponding hexadecimal digit from the table produces:

F 5 B 9 E 1

You have six hexadecimal digits corresponding to the six groups of four binary digits. Just to prove that it all works

out with no cheating, you can convert this number directly from hexadecimal to decimal by again using the analogy

with the meaning of a decimal number. The value of this hexadecimal number therefore works out as follows.

F5B9E1 as a decimal value is given by

15 × 165 + 5 × 164 + 11 × 163 + 9 × 162 + 14 × 161 + 1 × 160

This turns out to be

15,728,640 + 327,680 + 45,056 + 2,304 + 224 + 1

Thankfully, this adds up to the same number you got when converting the equivalent binary number to a decimal

value: 16,103,905. In C++, hexadecimal values are written with 0x or 0X as a prefix, so in code the value would be

written as 0xF5B9E1. Obviously, this means that 99 is not at all the same as 0x99.

The other very handy coincidence with hexadecimal numbers is that modern computers store integers in words

that are an even number of bytes, typically 2, 4, 8, or 16 bytes. A byte is 8 bits, which is exactly two hexadecimal digits

so any binary integer word in memory always corresponds to an exact number of hexadecimal digits.

Negative Binary Numbers

There’s another aspect to binary arithmetic that you need to understand: negative numbers. So far, I’ve assumed that

everything is positive—the optimist’s view—and so the glass is still half full. But you can’t avoid the negative side of

life—the pessimist’s perspective—that the glass is already half empty. How is a negative number represented in a

computer? Well, you have only binary digits at your disposal, so the solution has to be to use at least one of those to

indicate whether the number is negative or positive.:

For numbers that can be negative (referred to as signed numbers), you must first decide on a fixed length (in other

words, the number of binary digits) and then designate the leftmost binary digit as a sign bit. You have to fix the length

to avoid any confusion about which bit is the sign bit.

As you know, your computer’s memory consists of 8-bit bytes, so binary numbers are going to be stored in some

multiple (usually a power of 2) of 8 bits. Thus, you can have numbers with 8 bits, 16 bits, 32 bits, or whatever. As long

as you know what the length is in each case, you can find the sign bit—it’s just the leftmost bit. If the sign bit is 0, the

number is positive, and if it’s 1, the number is negative.

This seems to solve the problem. Each number consists of a sign bit that is 0 for positive values and 1 for negative

values, plus a given number of other bits that specify the absolute value of the number, the value without the sign in

other words. Changing +6 to –6 then just involves flipping the sign bit from 0 to 1. Unfortunately, this representation

carries a lot of overhead in terms of the complexity of the circuits that are needed to perform arithmetic. For this

reason, most computers take a different approach. You can get an idea of how this approach works by considering how

the computer would handle arithmetic with positive and negative values so that operations are as simple as possible.

Ideally, when two integers are added, you don’t want the computer to be messing about, checking whether

either or both of the numbers are negative. You just want to use simple “add” circuitry regardless of the signs of the

operands. The add operation will combine corresponding binary digits to produce the appropriate bit as a result, with

a carry to the next digit along where this is necessary. If you add –8 in binary to +12, you would really like to get the

answer +4 using the same circuitry that would apply if you were adding +3 and +8.

CHAPTER 1 ■ BASIC IDEAS

If you try this with the simplistic solution, which is just to set the sign bit of the positive value to 1 to make it

negative, and then perform the arithmetic with conventional carries, it doesn’t quite work:

12 in binary is 0000 1100

–8 in binary (you suppose) is 1000 1000

If you now add these together, you get 1001 0100

This seems to be –20, which isn’t what you wanted at all. It’s definitely not +4, which you know is 0000 0100. “Ah,”

I hear you say, “you can’t treat a sign just like another digit.” But that is just what you do want to do.

You can see how the computer would like to represent –8 by subtracting +12 from +4:

+4 in binary is 0000 0100

+12 in binary is 0000 1100

Subtracting 12 from 4 you get 1111 1000

For each digit after the fourth from the right, you had to “borrow” 1 to do the subtraction, just as you would when

performing decimal arithmetic. This result is supposed to be –8, and even though it doesn’t look like it, that’s exactly

what it is. Just try adding it to +12 or +15 in binary, and you’ll see that it works! Of course, if you want to produce –8 you

can always subtract +8 from 0.

What exactly did you get when you subtracted 12 from 4 or +8 from 0? What you have here is called the 2’s

complement representation of a negative binary number. You can produce the negative of any positive binary number

by a simple procedure that you can perform in your head. At this point, I need to ask you to have a little faith because

I’ll avoid getting into explanations of why it works. I’ll show you how you can create the 2’s complement form of a

negative number from a positive value, and you can prove to yourself that it does work. Let’s return to the previous

example, in which you need the 2’s complement representation of –8.

You start with +8 in binary:

0000 1000

You “flip” each binary digit, changing 0s to 1s and vice versa:

1111 0111

This is called the 1’s complement form. If you add 1 to this, you’ll get the 2’s complement form:

1111 1000

This is exactly the same as the representation of –8 you got by subtracting +12 from +4. Just to make absolutely

sure, let’s try the original sum of adding –8 to +12:

+12 in binary is 0000 1100

Your version of –8 is 1111 1000

If you add these together, you get 0000 0100

The answer is 4—magic. It works! The “carry” propagates through all the leftmost 1s, setting them back to 0. One fell

off the end, but you shouldn’t worry about that—it’s probably compensating for the one you borrowed from the end in the

subtraction you did to get –8. In fact, what’s happening is that you’re implicitly assuming that the sign bit, 1 or 0, repeats

forever to the left. Try a few examples of your own; you’ll find it always works, automatically. The great thing about the 2’s

complement representation of negative numbers is that it makes arithmetic very easy (and fast) for your computer.

CHAPTER 1 ■ BASIC IDEAS

Octal Values

Octal integers :are numbers expressed with base 8. Digits in an octal value can only be from 0 to 7. Octal is used

rarely these days. It was useful in the days when computer memory was measured in terms of 36-bit words because

you could specify a 36-bit binary value by 12 octal digits. Those days are long gone so why am I introducing it? The

potential confusion it can cause is the answer. You can still write octal constants in C++. Octal values are written

with a leading zero, so while 76 is a decimal value, 076 is an octal value that corresponds to 64 in decimal. So, here’s a

golden rule:

Note ■ Never write decimal integers with a leading zero. You’ll get either a value different from what you intended, or

an error message from the compiler.

Big-Endian and Little-Endian Systems

Integers are stored in memory as binary values in a contiguous sequence of bytes, commonly groups of 2, 4, 8, or

16 bytes. The question of the sequence in which the bytes appear can be very important—it’s one of those things that

doesn’t matter until it matters, and then it really matters.

Let’s consider the decimal value 262,657 stored as a 4-byte binary value. I chose this value because in binary it

happens to be

0000 0000 0000 0100 0000 0010 0000 0001

so each byte has a pattern of bits that is easily distinguished from the others. If you’re using a PC with an Intel

processor, the number will be stored as follows:

Byte address: 00 01 02 03

Data bits: 0000 0001 0000 0010 0000 0100 0000 0000

As you can see, the most significant eight bits of the value—the one that’s all 0s—are stored in the byte with the

highest address (last, in other words), and the least significant eight bits are stored in the byte with the lowest address,

which is the leftmost byte. This arrangement is described as little-endian.

If you’re using a machine based on a Motorola processor, the same data is likely to be arranged in memory like this:

Byte address: 00 01 02 03

Data bits: 0000 0000 0000 0100 0000 0010 0000 0001

Now the bytes are in reverse sequence with the most significant eight bits stored in the leftmost byte, which is the

one with the lowest address. This arrangement is described as big-endian. Some recent processors such as SPARC and

Power-PC processors are bi-endian, which means that the byte order for data is switchable between big-endian and

little endian.

Note ■ Regardless of whether the byte order is big-endian or little-endian, the bits within each byte are arranged with

the most significant bit on the left and the least significant bit on the right.

剩余619页未读，继续阅读

trifist00

粉丝: 0
资源: 2

C++入门指南：从基础到高级特性

Beginning C++17, 5th Edition

Beginning C++ Programming (kindle 格式)

Beginning c++ (作者 ivor horton)

beginning c++17: from novice to professional pdf

--------- beginning of system --------- beginning of main这两条是什么意思？

C++ std::sort

--------- beginning of system --------- beginning of main

c++ 字符串比较是否为开头

kafka+c++实现

c++ 类继承fstream重写write/read/seek方法

最新资源