逐步探索C++11：从基础到进阶

需积分: 10 33 浏览量更新于2024-07-23 收藏 3.98MB PDF 举报

"Exploring C++11" 是一本针对初学者的C++教程，它将C++11标准的知识点拆分成易于消化的小部分，逐步引导读者掌握这门语言。书中假设读者对C++或任何基于C的语言没有了解，通过一系列逻辑递进的小课时进行教学，学习者可以根据自己的节奏快速或缓慢地学习。本书的前言和其他非正文内容被放置在索引之后，方便读者使用书签和“内容概览”链接来快速访问。书中的章节涵盖了许多核心的C++11概念，包括： 1. 工具的磨炼：这部分可能涉及设置开发环境，编译器选项和调试工具的使用。 2. 阅读C++代码：介绍如何理解C++的语法结构和代码布局。 3. 整数表达式：讲解C++中的算术运算符和整型数据的处理。 4. 字符串：介绍std::string类以及字符串操作。 5. 简单输入：教授基本的输入处理，如从键盘获取用户输入。 6. 错误消息：解释编译错误和运行时错误的含义，以及如何调试。 7. for循环：讲解for循环的工作原理及其在程序中的应用。 8. 格式化输出：介绍如何使用iostream库进行格式化的输出。 9. 数组和向量：对比和使用数组与std::vector，包括动态内存管理和容器操作。 10. 算法和迭代器：探讨STL（标准模板库）中的算法和迭代器的概念。 11. 自增自减：介绍自增和自减运算符的用法及其在逻辑中的作用。 12. 条件和逻辑：讲解条件语句（if, else, switch）和逻辑运算符。 13. 复合语句：讨论复合语句块，如大括号包围的代码块。 14. 文件输入/输出：介绍如何读写文件，包括文件流的使用。 15. map数据结构：讲解关联容器std::map的特性及使用。 16. 类型别名：介绍using关键字创建类型别名，提高代码可读性。 17. 字符：深入字符类型，如char，以及Unicode和ASCII编码。 18. 字符类别：讲解字符分类，如字母、数字和标点符号的处理。 19. 大小写转换：探讨大小写转换函数和方法。通过这些探索，读者将逐步熟悉C++11的关键特性，并能编写出基本的C++程序。这本书适合那些想要进入C++编程领域，特别是对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.

剩余616页未读，继续阅读

jhjeong

粉丝: 0
资源: 2

逐步探索C++11：从基础到进阶

Exploring C++ 11

Exploring C++

RRT路径规划算法c++实现

rrt算法c++程序

C++RRT算法代码

应用C++编写RRT程序

RRT-Connect算法c++实现并注释

你知道如何用C++去设计一个自动生成无人机航线的程序吗

优化Quick-RRT*算法c++

最新资源