深入探索C++11

5星 · 超过95%的资源需积分: 9 36 浏览量更新于2024-07-20 2 收藏 4.02MB PDF 举报

"Exploring C++ 11, 2nd Edition" 本书是关于C++ 11标准的深入探索，旨在帮助读者理解和掌握C++ 11的新特性和改进。作者通过一系列精心设计的探索章节，逐步引导读者深入学习这一现代C++版本的核心概念和技术。 1. 关于作者和技术审阅者：书中提到了作者和审阅者的相关信息，他们可能都是C++领域的专家，确保了书中的内容准确无误。 2. 序言和致谢：这部分通常包含作者对书籍创作背景、目标读者及对支持者的感谢等内容。 3. 探索1：磨砺工具：这个章节可能是关于提升C++开发环境和编译器的使用技巧，包括如何更有效地利用IDE、调试器和其他开发工具。 4. 探索2：阅读C++代码：本章节可能涉及如何理解已有的C++代码，解析代码结构和编程风格，为后续学习打下基础。 5. 探索3：整数表达式：介绍C++ 11中处理整数类型的基本操作和表达式，可能包括算术运算、位操作等。 6. 探索4：字符串：涵盖C++ 11中的std::string类，讨论字符串的创建、操作和管理。 7. 探索5：简单输入：讲解如何从标准输入读取数据，可能包括基本的iostream库的使用。 8. 探索6：错误消息：讨论如何理解和处理编译时和运行时错误，以及调试策略。 9. 探索7：for循环：介绍C++的for循环语法，包括新的range-based for循环，以及它们在遍历容器时的应用。 10. 探索8：格式化输出：探讨如何使用iostream库进行格式化的输出，包括控制精度、对齐等。 11. 探索9：数组和向量：比较和对比C++中的原始数组和STL中的std::vector，包括内存管理和性能。 12. 探索10：算法和迭代器：讲解C++标准库中的算法和迭代器，如何高效地操作容器中的元素。 13. 探索11：增量和减量：讨论C++的自增自减操作符及其在不同情况下的行为。 14. 探索12：条件和逻辑：介绍if语句、switch语句以及逻辑运算符，讨论条件控制和逻辑判断。 15. 探索13：复合语句：讲解如何使用块（{}）组织代码，以及控制流程的其他结构。 16. 探索14：文件I/O：介绍C++ 11中读写文件的方法，包括基本的fstream类和相关操作。 17. 探索15：映射数据结构：深入研究std::map，讨论键值对的存储和查找。 18. 探索16：类型别名：解释using关键字和typedef的功能，以及如何创建和使用类型别名。 19. 探索17：字符：探讨C++中的字符类型，如char，以及Unicode和编码问题。这些章节涵盖了C++ 11的基础和进阶主题，从语言的基本构建块到标准库的使用，为读者提供了全面的C++ 11学习路径。无论是初学者还是经验丰富的开发者，都可以从中获得宝贵的知识和实践经验。

EXPLORATION 1 ■ HONINg YOuR TOOLs

Listing 1-2. Testing Your Compiler

/// Sort the standard input alphabetically.

/// Read lines of text, sort them, and print the results to the standard output.

/// If the command line names a file, read from that file. Otherwise, read from

/// the standard input. The entire input is stored in memory, so don’t try

/// this with input files that exceed available RAM.

///

/// Comparison uses a locale named on the command line, or the default, unnamed

/// locale if no locale is named on the command line.

#include <algorithm>

#include <cstdlib>

#include <fstream>

#include <initializer_list>

#include <iostream>

#include <locale>

#include <string>

#include <vector>

template<class C>

struct text : std::basic_string<C>

{

text() : text{""} {}

text(char const* s) : std::basic_string<C>(s) {}

text(text&&) = default;

text(text const&) = default;

text& operator=(text const&) = default;

text& operator=(text&&) = default;

};

/// Read lines of text from @p in to @p iter. Lines are appended to @p iter.

/// @param in the input stream

/// @param iter an output iterator

template<class Ch>

auto read(std::basic_istream<Ch>& in) -> std::vector<text<Ch>>

{

std::vector<text<Ch>> result;

text<Ch> line;

while (std::getline(in, line))

result.push_back(line);

return result;

}

/// Main program.

int main(int argc, char* argv[])

try

{

// Throw an exception if an unrecoverable input error occurs, e.g.,

// disk failure.

std::cin.exceptions(std::ios_base::badbit);

EXPLORATION 1 ■ HONINg YOuR TOOLs

// Part 1. Read the entire input into text. If the command line names a file,

// read that file. Otherwise, read the standard input.

std::vector<text<char>> text; ///< Store the lines of text here

if (argc < 2)

text = read(std::cin);

else

{

std::ifstream in(argv[1]);

if (not in)

{

std::perror(argv[1]);

return EXIT_FAILURE;

}

text = read(in);

}

// Part 2. Sort the text. The second command line argument, if present,

// names a locale, to control the sort order. Without a command line

// argument, use the default locale (which is obtained from the OS).

std::locale const& loc{ std::locale(argc >= 3 ? argv[2] : "") };

std::collate<char> const& collate( std::use_facet<std::collate<char>>(loc) );

std::sort(text.begin(), text.end(),

[&collate](std::string const& a, std::string const& b)

{

return collate.compare(a.data(), a.data()+a.size(),

b.data(), b.data()+b.size()) < 0;

}

);

// Part 3. Print the sorted text.

for (auto const& line : text)

std::cout << line << '\n';

}

catch (std::exception& ex)

{

std::cerr << "Caught exception: " << ex.what() << '\n';

std::cerr << "Terminating program.\n";

std::exit(EXIT_FAILURE);

}

catch (...)

{

std::cerr << "Caught unknown exception type.\nTerminating program.\n";

std::exit(EXIT_FAILURE);

}

I caught you peeking. In spite of my warning, you tried to read the source code, didn’t you? Just remember that

I deliberately wrote this program in a complicated fashion to test your tools. By the time you finish this book, you will

be able to read and understand this program. Even more important, you will be able to write it more simply and more

cleanly. Before you can run, however, you must learn to walk. Once you are comfortable working with your tools,

it’s time to start learning C++. The next Exploration begins your journey with a reading lesson.

EXPLORATION 2 ■ REAdINg C++ COdE

Listing 2-1 reads integers from the standard input and keeps track of the largest and smallest values entered.

After exhausting the input, it then prints those values. If the input contains no numbers, the program prints nothing.

Let’s take a closer look at the various parts of the program.

Comments

Line 1 begins with three consecutive slashes to start a comment. The comment ends at the end of the line. Actually,

you need only two slashes to signal the start of a comment (//), but as you will learn later in the book, the extra slash

has a special meaning.

Note that you cannot put a space between the slashes. That’s true in general for all the multicharacter symbols in

C++. It’s an important rule, and one you must internalize early. A corollary to the “no spaces in a symbol” rule is that

when C++ sees adjacent characters, it usually constructs the longest possible symbol, even if you can see that doing so

would produce meaningless results.

The other method you can use to write a comment in C++ is to begin the comment with /* and end it with */.

The difference between this style and the style demonstrated in Listing 2-1 is with this method, your comment can

span multiple lines. You may notice that some programs in this book use /** to start a comment. Much like the third

slash in Listing 2-1, this second asterisk (*) is magic, but unimportant at this time. A comment cannot nest within a

comment of the same style, but you can nest one style of comment in comments of the other style, as illustrated in

Listing 2-2.

Listing 2-2. Demonstrating Comment Styles and Nesting

/* Start of a comment /* start of comment characters are not special in a comment

// still in a comment

Still in a comment

no_longer_in_a_comment();

// Start of a comment /* start of comment characters are not special in a comment

no_longer_in_a_comment();

The C++ community uses both styles widely. Get used to seeing and using both styles.

Modify Listing 2-1 to change the /// comment to use the /** . . . */ style, then try to recompile the program.

What happens?

_____________________________________________________________

If you made the change correctly, the program should still compile and run normally. The compiler eliminates

comments entirely, so nothing about the final program should be different. (With one exception being that some

binary formats include a time stamp, which would necessarily differ from one compilation run to another.)

Headers

Lines 3 and 4 of Listing 2-1 import declarations and definitions from parts of the standard library. C++, like C and

many other languages, distinguishes between the core language and the standard library. Both are part of the

standard language, and a tool suite is incomplete without both parts. The difference is that the core language is

self-contained. For example, certain types are built-in, and the compiler inherently knows about them. Other types

are defined in terms of the built-in types, so they are declared in the standard library, and you must instruct the

compiler that you want to use them. That’s what lines 3 and 4 are all about.

In particular, line 3 informs the compiler about the names of the standard I/O streams (cin for the standard input

and cout for the standard output), the input operator (>>), and the output operator (<<). Line 4 brings in the name

numeric_limits. Note that names from the standard library generally begin with std:: (short for “standard”).

EXPLORATION 2 ■ REAdINg C++ COdE

In C++ parlance, the #include keyword is also a verb, as in “line 3 includes the iostream header,” “line 4 includes

the limits header,” and so on. A header is typically a file that contains a series of declarations and definitions.

(A declaration is a kind of definition. A definition tells the compiler more about a name than a declaration. Don’t

worry about the difference yet, but notice when I use declaration and when I use definition.) The compiler needs

these declarations and definitions, so it knows what to do with names such as std::cin. Somewhere in the

documentation for your C++ compiler and standard library is the location for its standard headers. If you are curious,

visit that folder or directory and see what you can find there, but don’t be disappointed if you can’t read the headers.

The C++ standard library makes full use of the entire range of C++ language features. It’s likely you won’t be able to

decipher most of the library until after you’ve made it through a large part of this book.

Another important C++ rule: the compiler has to know what every name means. A human can often infer

meaning or at least a part of speech from context. For example, if I were to say, “I furbled my drink all over my shirt,”

you may not know exactly what furbled means, but you can deduce that it is the past tense of a verb and that it

probably implies something undesirable and somewhat messy.

C++ compilers are a lot dumber than you. When the compiler reads a symbol or identifier, it must know exactly

what the symbol or identifier means and what part of “speech” it is. Is the symbol a punctuator (such as the

statement-ending semicolon) or an operator (such as a plus sign for addition)? Is the identifier a type? A function?

A variable? The compiler also has to know everything you can do with that symbol or name, so it can correctly

compile the code. The only way it can know is for you to tell it, and the way you tell it is by writing a declaration or by

importing a declaration from a header. And that’s what #include directives are all about.

Any line that begins with # ends at the end of the line. C++ has several different # directives, but only #include

concerns us at this time. Inside the angle brackets must be a header name, which is typically a standard library header,

but it might also be a header from a third-party library.

Later in the book, you’ll even learn to write your own headers.

Modify line 4 to misspell limits as stimil. Try to compile the program. What happens?

_____________________________________________________________

The compiler cannot find any header named stimil, so it issues a message. Then it may try to compile the

program, but it doesn’t know what std::numeric_limits is, so it issues one or more messages. Some compilers

cascade messages, which means every use of std::numeric_limits produces additional messages. The actual error

becomes lost in the noise. Focus on the first one or few messages the compiler issues. Fix them, then try again. As you

gain experience with C++, you will learn which messages are mere noise and which are important. Unfortunately,

most compilers will not tell you, for example, that you can’t use std::numeric_limits until you include the <limits>

header. Instead, you need a good C++ language reference, so you can look up the correct header on your own. The

first place to check is the documentation that accompanies your compiler and library. Authors have been slower

than compiler-writers to catch up to the C++ 11 standard, so keep checking the web site and bookstores for updated

references.

Most programmers don’t use <limits> much; Listing 2-1 included it only to obtain the definition of

std::numeric_limits. On the other hand, almost every program in this book uses <iostream>, because it declares

the names and types of the I/O stream objects, std::cin and std::cout. There are other I/O headers, but for basic

console interactions, you need only <iostream>. You will meet more headers in coming Explorations.

Main Program

Every C++ program must have int main(), as shown on line 6. You are permitted a few variations on a theme, but the

name main is crucial. A program can have only one main, and the name must be spelled using all lowercase characters.

The definition must start with int.

www.allitebooks.com

剩余616页未读，继续阅读

ibelievemylove

粉丝: 2
资源: 15

Exploring C++

Exploring C++ 无水印pdf

Exploring C++ 11(2nd Edition 2013)-master_C++11_

Exploring C++ The Programmers Introduction to C++

Exploring C++ The Programmer's Introduction to C++.

[C++探秘 68讲贯通C++].(.Exploring.C++.The.Programmer’s.Introduction.to.C++.).里斯纳.扫描版

2018 CppCon Unwinding the Stack - Exploring how C++ Exceptions work on Windows - James McNellis-计算机科学

Exploring the Raspberry Pi 2 with C++.pdf 2016

Exploring Computer Science

Exploring Java.pdf

最新资源