C++全阶教程：从入门到高级（英文版）

需积分: 9 130 浏览量更新于2024-07-18 1 收藏 4.43MB PDF 举报

本篇文档是一份全面的C++教程，特别适合各个级别的程序员，包括C/C++初学者、中级开发人员和高级专家。无论是作为参考手册还是教学材料，英文版的特性使其具有很高的实用性。教程涵盖了广泛的C++语言内容，从基础概念到现代C++特性和实践技巧。首先，文档的核心部分是"C++ Language Reference"，这是对C++语言规范的详尽介绍，包括C++类型系统、统一初始化和委托构造函数，这些有助于理解类和对象的生命周期以及资源管理。通过"Object Lifetime and Resource Management"章节，读者可以学习如何正确处理对象的创建和销毁，特别是RAII（Resource Acquisition Is Initialization）原则，这是一种避免资源泄露的有效方法。 "Smart Pointers"章节深入探讨了现代C++中的智能指针，它们在内存管理和对象所有权转移方面发挥着关键作用。接下来的"Pimpl for Compile-Time Encapsulation"部分讲解了如何通过Pimpl（Pointer to Implementation）策略实现编译时封装，提高代码的可维护性和隐藏实现细节。 "Containers"和"Algorithms"是数据结构和算法的基础，文档会介绍现代C++标准库提供的容器（如vector、map等）和高效算法，帮助开发者构建高性能应用程序。在"String and I/O Formatting"部分，读者将学到字符串操作和输入输出格式化的相关知识。 "Errors and Exception Handling"是每个程序员都需要掌握的主题，文档详细解释了错误处理机制和异常处理的最佳实践，确保程序的健壮性。"Portability At A ABI Boundaries"关注跨平台编程，提供关于边界兼容性的指导。此外，文档还涉及语言的语法细节，如"Lexical Conventions"，包括文件翻译概述、字符集、注释、标识符、关键字、标点符号、数值、布尔和指针字面量、字符串和字符字面量，以及用户自定义字面量的用法。 "Basic Concepts"介绍了基础概念，如声明和定义、作用域、程序和链接关系、程序启动和终止，以及Lvalues和Rvalues的概念。这部分内容对于理解C++的语义至关重要。 "Temporary Objects"、"Alignment"、"alignof and alignas"讨论了临时对象的生命周期和内存对齐，这对于性能优化和内存管理至关重要。此外，"Trivial, standard-layout, and POD types"区分了不同类型的存储方式，"Fundamental Types"则涵盖了C++的基本数据类型，如`nullptr`的使用。最后，文档分别介绍了`bool`、`false`和`true`等基本布尔类型，以及`void`类型的特性和用法，为理解C++的逻辑结构提供了坚实的基础。这份C++教程深入浅出，无论你是C++新手还是资深开发者，都能从中获得宝贵的知识和实践经验。

double 8 bytes The default choice for floating point

values.

bool 1 byte Represents values that can be either

true or false.

char 1 byte Use for ASCII characters in older C-style

strings or std::string objects that will

never have to be converted to

UNICODE.

wchar_t 2 bytes Represents "wide" character values that

may be encoded in UNICODE format

(UTF-16 on Windows, other operating

systems may differ). This is the

character type that is used in strings of

type std::wstring .

unsigned char 1 byte C++ has no built-in byte type. Use

unsigned char to represent a byte

value.

unsigned int 4 bytes Default choice for bit flags.

long long 8 bytes Represents very large integer values.

TYPE SIZE COMMENT

The void type

const type qualifier

const double PI = 3.1415;

PI = .75 //Error. Cannot modify const variable.

The void type is a special type; you cannot declare a variable of type void , but you can declare a variable of type

void * (pointer to void ), which is sometimes necessary when allocating raw (un-typed) memory. However,

pointers to void are not type-safe and generally their use is strongly discouraged in modern C++. In a function

declaration, a void return value means that the function does not return a value; this is a common and acceptable

use of void . While the C language required functions that have zero parameters to declare void in the parameter

list, for example, fou(void) , this practice is discouraged in modern C++ and should be declared fou() . For more

information, see Type Conversions and Type Safety.

Any built-in or user-defined type may be qualified by the const keyword. Additionally, member functions may be

const -qualified and even const -overloaded. The value of a const type cannot be modified after it is initialized.

The const qualifier is used extensively in function and variable declarations and "const correctness" is an

important concept in C++; essentially it means to use const to guarantee, at compile time, that values are not

modified unintentionally. For more information, see const.

A const type is distinct from its non-const version; for example, const int is a distinct type from int . You can

use the C++ const_cast operator on those rare occasions when you must remove const-ness from a variable. For

more information, see Type Conversions and Type Safety.

String types

User

defined types

Pointer types

Strictly speaking, the C++ language has no built-in string type; char and wchar_t store single characters - you

must declare an array of these types to approximate a string, adding a terminating null value (for example, ASCII

'\0' ) to the array element one past the last valid character (also called a C-style string). C-style strings required

much more code to be written or the use of external string utility library functions. But in modern C++, we have

the Standard Library types std::string (for 8-bit char -type character strings) or std::wstring (for 16-bit

wchar_t -type character strings). These C++ Standard Library containers can be thought of as native string types

because they are part of the standard libraries that are included in any compliant C++ build environment. Simply

use the #include <string> directive to make these types available in your program. (If you are using MFC or ATL,

the CString class is also available, but is not part of the C++ standard.) The use of null-terminated character arrays

(the C-style strings previously mentioned) is strongly discouraged in modern C++.

When you define a class , struct , union , or enum , that construct is used in the rest of your code as if it were a

fundamental type. It has a known size in memory, and certain rules about how it can be used apply to it for

compile-time checking and, at runtime, for the life of your program. The primary differences between the

fundamental built-in types and user-defined types are as follows:

The compiler has no built-in knowledge of a user-defined type. It learns of the type when it first encounters

the definition during the compilation process.

You specify what operations can be performed on your type, and how it can be converted to other types, by

defining (through overloading) the appropriate operators, either as class members or non-member

functions. For more information, see Function Overloading.

They do not have to be statically typed (the rule that an object's type never changes). Through the

mechanisms of inheritance and polymorphism, a variable declared as a user-defined type of class (referred

to as an object instance of a class) might have a different type at run-time than at compile time. For more

information, see Inheritance.

Dating back to the earliest versions of the C language, C++ continues to let you declare a variable of a pointer type

by using the special declarator * (asterisk). A pointer type stores the address of the location in memory where the

actual data value is stored. In modern C++, these are referred to as raw pointers, and are accessed in your code

through special operators * (asterisk) or -> (dash with greater-than). This is called dereferencing, and which one

that you use depends on whether you are dereferencing a pointer to a scalar or a pointer to a member in an object.

Working with pointer types has long been one of the most challenging and confusing aspects of C and C++

program development. This section outlines some facts and practices to help use raw pointers if you want to, but in

modern C++ it’s no longer required (or recommended) to use raw pointers for object ownership at all, due to the

evolution of the smart pointer (discussed more at the end of this section). It is still useful and safe to use raw

pointers for observing objects, but if you must use them for object ownership, you should do so with caution and

very careful consideration of how the objects owned by them are created and destroyed.

The first thing that you should know is declaring a raw pointer variable will allocate only the memory that is

required to store an address of the memory location that the pointer will be referring to when it is dereferenced.

Allocation of the memory for the data value itself (also called backing store) is not yet allocated. In other words, by

declaring a raw pointer variable, you are creating a memory address variable, not an actual data variable.

Dereferencing a pointer variable before making sure that it contains a valid address to a backing store will cause

undefined behavior (usually a fatal error) in your program. The following example demonstrates this kind of error:

int* pNumber; // Declare a pointer-to-int variable.

*pNumber = 10; // error. Although this may compile, it is

// a serious error. We are dereferencing an

// uninitialized pointer variable with no

// allocated memory to point to.

int number = 10; // Declare and initialize a local integer

// variable for data backing store.

int* pNumber = &number; // Declare and initialize a local integer

// pointer variable to a valid memory

// address to that backing store.

...

*pNumber = 41; // Dereference and store a new value in

// the memory pointed to by

// pNumber, the integer variable called

// "number". Note "number" was changed, not

// "pNumber".

void someFunction() {

unique_ptr<MyClass> pMc(new MyClass);

pMc->DoSomeWork();

}

// No memory leak. Out-of-scope automatically calls the destructor

// for the unique_ptr, freeing the resource.

Windows data types

The example dereferences a pointer type without having any memory allocated to store the actual integer data or a

valid memory address assigned to it. The following code corrects these errors:

The corrected code example uses local stack memory to create the backing store that pNumber points to. We use a

fundamental type for simplicity. In practice, the backing store for pointers are most often user-defined types that

are dynamically-allocated in an area of memory called the heap (or free store) by using a new keyword expression

(in C-style programming, the older malloc() C runtime library function was used). Once allocated, these variables

are usually referred to as objects, especially if they are based on a class definition. Memory that is allocated with

new must be deleted by a corresponding delete statement (or, if you used the malloc() function to allocate it,

the C runtime function free() ).

However, it is easy to forget to delete a dynamically-allocated object- especially in complex code, which causes a

resource bug called a memory leak. For this reason, the use of raw pointers is strongly discouraged in modern

C++. It is almost always better to wrap a raw pointer in a smart pointer, which will automatically release the

memory when its destructor is invoked (when the code goes out of scope for the smart pointer); by using smart

pointers you virtually eliminate a whole class of bugs in your C++ programs. In the following example, assume

MyClass is a user-defined type that has a public method DoSomeWork();

For more information about smart pointers, see Smart Pointers.

For more information about pointer conversions, see Type Conversions and Type Safety.

For more information about pointers in general, see Pointers.

In classic Win32 programming for C and C++, most functions use Windows-specific typedefs and #define macros

(defined in windef.h ) to specify the types of parameters and return values. These Windows data types are mostly

just special names (aliases) given to C/C++ built-in types. For a complete list of these typedefs and preprocessor

Value Types

(

Modern C++

)

12/21/2017 • 3 min to read • Edit Online

Value vs. reference types

// cl /EHsc /nologo /W4

class MyRefType {

private:

MyRefType & operator=(const MyRefType &);

MyRefType(const MyRefType &);

public:

MyRefType () {}

};

int main()

{

MyRefType Data1, Data2;

// ...

Data1 = Data2;

}

test.cpp(15) : error C2248: 'MyRefType::operator =' : cannot access private member declared in class

'MyRefType'

meow.cpp(5) : see declaration of 'MyRefType::operator ='

meow.cpp(3) : see declaration of 'MyRefType'

Value types and move efficiency

C++ classes are by default value types. This topic provides an introductory overview of value types and issues

relating to their use.

As previously stated, C++ classes are by default value types. They can be specified as reference types, which enable

polymorphic behavior to support object-oriented programming. Value types are sometimes viewed from the

perspective of memory and layout control, whereas reference types are about base classes and virtual functions for

polymorphic purposes. By default, value types are copyable, which means there is always a copy constructor and a

copy assignment operator. For reference types, you make the class non-copyable (disable the copy constructor and

copy assignment operator) and use a virtual destructor, which supports their intended polymorphism. Value types

are also about the contents, which, when they are copied, always give you two independent values that can be

modified separately. Reference types are about identity - what kind of object is it? For this reason, "reference types"

are also referred to as "polymorphic types".

If you really want a reference-like type (base class, virtual functions), you need to explicitly disable copying, as

shown in the MyRefType class in the following code.

Compiling the above code will result in the following error:

Copy allocation overhead is avoided due to new copy optimizations. For example, when you insert a string in the

middle of a vector of strings, there will be no copy re-allocation overhead, only a move- even if it results in a grow

of the vector itself. This also applies to other operations, for instance performing an add operation on two very

large objects. How do you enable these value operation optimizations? In some C++ compilers, the compiler will

enable this for you implicitly, much like copy constructors can be automatically generated by the compiler.

剩余967页未读，继续阅读

普通网友

粉丝: 0
资源:
3

C++全阶教程：从入门到高级（英文版）

四川大学C++课件（英文）

C++程序设计语言（中文版+英文版）

visual c++6.0英文版

最好的opengl，c++教程

source_insight教程及技巧(大全).pdf

c++ stl教程 pdf下载

w3cschool c++ 教程 pdf

给我来一份C++的学习教程

c++primer第五版英文版

c++程序设计教程第三版答案钱能

最新资源