C++ Succinctly: C#开发者进阶现代C++编程指南

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

"《C++ Succinctly》是一本专为高级C#开发者设计的现代C++编程指南，旨在通过已有的C#知识扩展编程技能。该书旨在帮助读者快速掌握C++的基础，无论是为了即将进行的C++项目，还是想要学习一门新语言，都提供了全面的入门教程。作者Michael B. McLaughlin以Daniel Jebaraj的前言开篇，强调了版权信息，提醒读者此书需从官方 Syncfusion网站（www.syncfusion.com）下载，并遵循严格的个人和教育使用许可条款。本书共包含2501 Aerial Center Parkway, Suite 200, Morrisville, NC 27560, USA 的Syncfusion Inc.发行，所有权利保留。免费下载需要填写注册表单，若非正规途径获取，也建议用户注册并从官网获取正版资源。读者务必确保遵守版权协议，因为此书仅限于个人阅读或教育目的，任何形式的再分发都是被禁止的。内容涵盖了广泛的章节，包括但不限于C++的基本概念、数据类型、控制结构、函数和对象、模板、STL（Standard Template Library）以及现代C++特性如RAII（Resource Acquisition Is Initialization）、智能指针等。此外，书中还包含了实用的例子和练习，帮助读者巩固所学知识，并逐步提升编程实践能力。编辑Clay Burch博士，作为Syncfusion Inc.技术支持部的总监，对全书进行了审阅和修订，确保了内容的专业性和易读性。读者可以通过目录了解到书中的详细结构，从而有条不紊地探索C++的世界。《C++ Succinctly》是一本适合C#开发者转型或深入了解C++的理想资源，它提供了一个清晰、简洁的学习路径，帮助读者跨越语言障碍，快速步入高效、现代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页未读，继续阅读

wulixu

粉丝: 1
资源: 1

C++ Succinctly: C#开发者进阶现代C++编程指南

c++狼人杀 c++狼人杀

c++代码 c++代码 c++代码

c++ 通讯录 c++c++ 通讯录

C++

c++小游戏 c++小游戏

C++车牌识别系统(c++)

Effective C++ & More Effective C++.chm

ISO C++最新标准(C++11)

标准C++宝典（C++高手必备）

DevC++6.0 C/C++开发工具

最新资源