C++ Succinctly：7天快速入门指南

需积分: 10 180 浏览量更新于2024-07-25 1 收藏 2.23MB PDF 举报

"7天让你入门c++，国外Succinctly精品" 这是一份由Michael B. McLaughlin编写的，Daniel Jebaraj作序的C++学习资料，源自国外出版社Syncfusion Inc.的"Succinctly"系列。这本书特别适合初学者，旨在帮助读者在短短7天内掌握C++的基础知识。Succinctly系列以其简洁明了的风格著称，旨在高效地传授关键概念。 C++是一种通用的、面向对象的编程语言，它在软件开发领域占据着重要的地位。C++结合了C语言的效率和高级语言的抽象能力，支持过程化编程、面向对象编程以及泛型编程。学习C++，你需要理解以下关键知识点： 1. **基础语法**：包括变量、数据类型（如int、float、char等）、运算符、流程控制（如if语句、switch语句、循环结构）。 2. **函数**：函数是C++中的基本模块，用于封装可重用的代码。理解函数的定义、调用和参数传递至关重要。 3. **指针**：C++的指针允许直接操作内存地址，这是C++强大而灵活的特性之一。你需要学习如何声明、初始化和操作指针，以及了解指针与数组、函数的关系。 4. **类与对象**：C++的核心是面向对象编程，类是对象的蓝图，对象则是类的实例。你需要理解封装、继承和多态等概念。 5. **模板**：C++的模板允许创建泛型代码，可以用于处理不同类型的参数，增加了代码的复用性。 6. **异常处理**：通过try、catch和throw关键字，C++提供了异常处理机制，用于捕获和处理运行时错误。 7. **标准库**：C++标准库提供了大量预定义的类和函数，如输入/输出流（iostream）、容器（如vector、list、map）和算法。 8. **内存管理**：C++允许直接管理内存，包括动态内存分配和释放，但这也意味着需要理解内存泄漏和野指针问题。 9. **STL（Standard Template Library）**：STL是C++标准库的一部分，包含容器、迭代器、算法和函数对象，是C++编程的强大工具。 10. **C++11及更新版本**：随着C++标准的发展，C++11引入了许多新特性，如右值引用、lambda表达式、自动类型推断（auto关键字）和并发编程支持。完成这本书的学习后，你将对C++有坚实的理解，并能够编写简单的程序。记住，实际编程经验是掌握任何编程语言的关键，所以边学边练是非常必要的。尽管本书可能不涉及深入的高级主题，但它为你打下了一个良好的基础，为后续更深入的学习铺平道路。

 int64_t

 uint8_t

 uint16_t

 uint32_t

 uint64_t

These types have their use, but you will find that most APIs do not use them; instead, they use the

fundamental types directly. This can make your programming confusing, as you constantly need to check

the underlying fundamental type to ensure you do not end up with unintended truncation or expansion.

These types might come into use more, so I recommend checking for their usage in major libraries and

APIs from time to time and adjusting your code accordingly if they become widely adopted. Of course, if

you absolutely need a variable to be, for example, an unsigned 32-bit integer, you should certainly make

use of uint32_t and make any adjustments for API calls and portability as needed.

Floating-point numbers are the same as far as size order rules. They go from float to double to long

double. In Visual C++, float is a 32-bit floating-point number and double and long double are both

64-bit floating point numbers (long double is not larger than double, in other words).

C++ does not have any native type that is comparable to C#’s decimal type. However, one of the nice

things about C++ is there are typically a large number of free or inexpensive libraries that you can license.

For example, there’s the decNumber library, the Intel Decimal Floating Point Math Library, and the GNU

Multiple Precision Arithmetic Library. None are exactly compatible with C#’s decimal type, but if you are

writing for Windows systems only, then you can use the DECIMAL data type to get that compatibility if

needed, along with the Decimal Arithmetic Functions and the Data Type Conversion Functions.

There is also a Boolean type, bool, which can be true or false. In Visual C++, a bool takes up a byte.

Unlike in C#, a bool can be transformed into an integer type. When false, it has an integer-equivalent

value of 0, and when true, it has a value of 1. So the statement bool result = true == 1; will compile

and result will evaluate to true when the statement has been executed.

Then there is the wchar_t type, which holds a wide character. A wide character’s size varies based on

the platform. On Windows platforms, it is a 16-bit character. It is the equivalent of C#’s char type. It is

frequently used to construct strings. We will discuss strings in another chapter since many variants can be

used for strings.

Lastly, there is the void type, which is used the same way it is in C#. And there is a std::nullptr_t

type, which is messy to explain properly, but basically is there to be the type of the nullptr literal, which

is what you should use instead of NULL or a literal 0 (zero) to check for null values.

Enumerations

Enumerations are fairly similar to each other in C++ and C#. C++ has two types of enums: scoped and

un-scoped.

A scoped enumeration is defined as either an enum class or an enum struct. There is no difference

between the two. An un-scoped enumeration is defined as a plain enum. Let’s look at a sample:

Sample: EnumSample\EnumSample.cpp

#include <iostream>

#include <ostream>

#include <string>

#include "../pchar.h"

enum class Color

{

Red,

Note: In C++, the scope resolution operator is ::. We’ll discuss this in more detail later on. For now,

just think of it as serving many of the same purposes as the . operator in C#.

This code will give the following output:

As you can see in the sample, the scoped Color enumeration requires you to access its members in the

same way as C# by prefacing the enumeration member with the enumeration’s name and the scope

resolution operator. By contrast, the un-scoped Flavor enumeration allows you simply to specify the

members without any prefix. For this reason, I think it’s better practice to prefer scoped enumerations:

You minimize the risks of naming collisions and lessen namespace pollution.

Notice that there is another difference with scoped enumerations: When we wanted to output the

numerical value of the scoped Color enum, we had to use the static_cast operator to convert it to an

int, while we did not need to do any casting for the un-scoped Flavor enumeration.

For the Flavor enumeration, we specified the underlying type as being an unsigned short int. You can

also specify the underlying type for scoped enumerations. Specifying the underlying type is optional, but

is mandatory if you wish to use forward declaration with an un-scoped enumeration. Forward declaration

is a way to speed up program compile times by only telling the compiler what it needs to know about a

type rather than forcing it to compile the whole header file the type is defined in.

We will look at this later on. For now, just remember that an un-scoped enumeration must have its

underlying type explicitly specified in order to use a forward declaration of it; a scope enumeration does

not require specification of its underlying type to use a forward declaration of it (the underlying type will be

int if none is specified).

case Chocolate:

flavor = L"Chocolate";

break;

case Strawberry:

flavor = L"Strawberry";

break;

case Mint:

flavor = L"Mint";

break;

default:

break;

}

std::wcout << L"Flavor is " << flavor.c_str() << L" (" << f <<

L"). Color is " << color.c_str() << L" (" <<

static_cast<int>(c) << L")." << std::endl <<

L"The size of Flavor is " << sizeof(Flavor) <<

L"." << std::endl <<

L"The size of Color is " << sizeof(Color) <<

L"." << std::endl;

return 0;

}

Flavor is Mint (3). Color is Orange (1).

The size of Flavor is 2.

The size of Color is 4.

You can do the same thing with enumerations in C++ as you can in C# in terms of explicitly assigning

values to members, and in terms of creating flag enumerations. You do it all the same way, except you

don’t need to apply anything like the FlagAttribute in C++ to create flag enumerations; you just assign

the correct values and proceed from there.

std::wcout, std::wcerr, std::wcin

The std::wcout << L”Flavor... code outputs wide character data to the standard output stream. In

the case of a console program such as this, the standard output is the console window. There is also a

std::wcerr output stream, which will output wide character data to the standard error output stream.

This is also the console window, but you can redirect std::wcout output to one file and std::wcerr

output to another file. There is also a std::wcin for inputting data from the console. We won’t explore

this, nor will we explore their byte counterparts: std::cout, std::cerr, and std::cin.

Just to let you see how the input looks, here’s an example.

Sample: ConsoleSample\ConsoleSample.cpp

#include <iostream>

#include <ostream>

#include <string>

#include "../pchar.h"

struct Color

{

float ARGB[4];

void A(float value) { ARGB[0] = value; }

float A(void) const { return ARGB[0]; }

void R(float value) { ARGB[1] = value; }

float R(void) const { return ARGB[1]; }

void G(float value) { ARGB[2] = value; }

float G(void) const { return ARGB[2]; }

void B(float value) { ARGB[3] = value; }

float B(void) const { return ARGB[3]; }

};

// This is a stand-alone function, which happens to be a binary

// operator for the << operator when used with a wostream on

// the left and a Color instance on the right.

std::wostream& operator<<(std::wostream& stream, const Color& c)

{

stream << L"ARGB:{ " << c.A() << L"f, " << c.R() << L"f, " <<

c.G() << L"f, " << c.B() << L"f }";

return stream;

}

int _pmain(int /*argc*/, _pchar* /*argv*/[])

{

std::wcout << L"Please input an integer and then press Enter: ";

int a;

std::wcin >> a;

std::wcout << L"You entered '" << a << L"'." << std::endl;

std::wcout << std::endl <<

The previous code is a fairly simple demo. It has no error checking, for instance. So, if you enter an

incorrect value for the integer, it will just run through to the end with std::wcin returning instantly without

any data (that’s what it does unless and until you resolve the error).

If you are interested in iostream programming, including using things like std::wofstream to output data

to a file and std::wifstream to read data in from a file (they work the same as std::wcout and

std::wcin, just with added functionality for dealing with the fact that they work with files), see the MSDN

iostream programming pages. Learning all the ins and outs of streams could easily fill a book just on its

own.

One last thing though. You’ve undoubtedly noticed that the stream functionality looks a bit odd with the bit

shifting operators << and >>. That’s because these operators have been overloaded. While you would

expect the bit shift operators to act a certain way on integers, there isn’t any specific expectation you’re

likely to have about how they should work when applied to an output stream or an input stream,

respectively. So the C++ Standard Library streams have co-opted these operators to use them for

inputting and outputting data to streams. When we want the ability to read in or write out a custom type

that we’ve created (such as the previous Color structure), we simply need to create an appropriate

operator overload. We’ll learn more about operator overloading later in the book, so don’t worry if it’s a bit

confusing right now.

Classes and Structures

The difference between a class and a structure in C++ is simply that a structure’s members default to

public whereas a class' members default to private. That's it. They are otherwise the same. There is no

value-type versus reference-type distinction as there is in C#.

That said, typically you will see programmers use classes for elaborate types (combinations of data and

functions) and structures for simple data-only types. Normally, this is a stylistic choice that represents the

non-object-oriented origins of structure in C, making it easy to differentiate quickly between a simple data

container versus a full-blown object by looking to see if it's a structure or a class. I recommend following

this style.

L"Please enter a noun (one word, no spaces) " <<

L"and then press Enter: ";

std::wstring noun;

// wcin breaks up input using white space, so if you include a space or

// a tab, then it would just put the first word into noun and there

// would still be a second word waiting in the input buffer.

std::wcin >> noun;

std::wcerr << L"The " << noun << L" is on fire! Oh no!" << std::endl;

Color c = { { 100.0f/255.0f, 149.0f/255.0f, 237.0f/255.0f, 1.0f } };

// This uses our custom operator from above. Come back to this sample

// later when we've covered operator overloading and this should make

// much more sense.

std::wcout << std::endl <<

L"Cornflower Blue is " << c << L"." << std::endl;

return 0;

}

剩余122页未读，继续阅读

internetak47

粉丝: 1
资源: 9

C++ Succinctly：7天快速入门指南

teach yourself C++ in 21 days

teach yourself c++ in 21 days

最好的C++入门速成教材，1-2天可看完

c++ Succinctly

ionic succinctly快速入门

Scala Succinctly

electron succinctly

Hadoop Succinctly

HBase Succinctly

Docker Succinctly

最新资源