Effective Modern C++精华概览

需积分: 9 145 浏览量更新于2024-07-22 1 收藏 10.7MB PDF 举报

"Effective Modern C++ Sampler" 《Effective Modern C++ Sampler》是一本针对C++11和C++14新特性的指南，由经典书籍《Effective C++》的作者Scott Meyers全新修订编写。这本书旨在帮助开发者更好地理解和利用C++的新特性，提高编程效率和代码质量。然而，需要注意的是，本资源仅为原书的一部分，提供了部分内容供读者预览和学习。 1. **模板类型推断（Template Type Deduction）** - 在C++11中，编译器能够自动推断模板参数的类型，这对于使用模板函数和类模板至关重要。 - 了解如何观察和调试推断出的类型可以帮助调试和理解代码的行为。 2. **auto关键字** - auto关键字允许编译器自动推断变量的类型，简化了代码并减少了冗余。但也要注意，过度使用可能会降低代码的可读性。 - 使用auto时，要确保推断出的类型与预期一致，以避免意外的类型转换或错误。 3. **decltype关键字** - decltype基于表达式的类型来声明变量，常用于动态获取类型，特别是在元编程和模板编程中。 - 使用decltype要注意，它会忽略隐式转换，只返回表达式实际的类型。 4. **查看推导出的类型** - 能够查看推导出的类型是调试和理解模板和auto的关键。通过使用`typeid`或在编译器诊断信息中查找，可以检查推导出的类型是否正确。 5. **auto与显式类型声明** - 在多数情况下，使用auto可以使代码更简洁。然而，对于复杂类型或为了提高代码可读性，有时显式指定类型仍然是必要的。 6. **类型初始化语法的区别（() vs {}）** - C++11引入了统一的初始化语法，但()和{}有不同的语义。()用于调用构造函数，而{}用于列表初始化，后者在避免意外的隐式类型转换时特别有用。 7. **nullptr的使用** - nullptr是C++11引入的新的空指针常量，优于0和NULL，因为它是类型的，不会与整数混淆。 8. **别名声明与typedef** - C++11的别名声明提供了一种定义类型别名的新方式，它比typedef更清晰且不易引发某些边缘情况的错误。 9. **范围限定枚举（Scoped Enums）** - 范围限定枚举增强了枚举的封装性，防止了枚举值与其他命名空间中的值冲突。 10. **删除函数（Deleted Functions）** - 删除函数是一种明确禁止某些操作的方式，优于私有未定义函数，因为它们给出了明确的编译错误信息。 11. **override关键字** - override关键字确保了函数是作为基类中特定虚函数的重载，避免了因拼写错误或其他原因导致的非预期行为。 12. **const_iterator的使用** - const_iterator通常用于只读遍历容器，避免了意外修改容器的风险，提高了代码的健壮性。 13. **constexpr的使用** - constexpr允许在编译时计算函数结果，增强了元编程能力，并确保了性能优化。 14. **线程安全的const成员函数** - 对于const成员函数，应考虑其在多线程环境下的安全性，特别是在静态数据成员或全局状态相关的操作中。 15. **noexcept宣告** - 函数声明为noexcept表明该函数不会抛出异常，有助于异常安全性和优化。 16. **值传递与移动语义** - 对于廉价移动的对象，考虑使用值传递，可以利用RVO（返回值优化）和NRVO（命名返回值优化）提升性能。 17. **emplace插入** - emplace方法允许直接在容器内构建对象，减少了不必要的复制和移动，提高了效率。 18. **特殊类型初始化** - C++11引入的特殊类型初始化，如列表初始化、直接初始化等，提供了更多控制对象创建方式的手段。这些是《Effective Modern C++》中的一部分关键知识点，它们展示了C++11和C++14新特性如何提升代码质量和效率。掌握这些技巧，能帮助程序员写出更加现代、高效且易于维护的C++代码。

Page 6

class Widget {

public:

Widget(Widget&& rhs); // rhs is an lvalue, though it has

… // an rvalue reference type

};

Here, it’d be perfectly valid to take rhs’s address inside Widget’s move construc-

tor, so rhs is an lvalue, even though its type is an rvalue reference. (By similar rea-

soning, all parameters are lvalues.)

This code example demonstrates several conventions I typically follow:

 The class name is Widget. I use Widget whenever I want to refer to an arbi-

trary user-defined type. Unless I need to show specific details of the class, I use

Widget without declaring it.

 I use the parameter name rhs, which stands for “right-hand side.” It’s my pre-

ferred parameter name for the move operations (i.e., move constructor and

move assignment operator) and the copy operations (i.e., copy constructor and

copy assignment operator), though I also employ it for the right-hand parame-

ter of binary operators:

Matrix operator+(const Matrix& lhs, const Matrix& rhs);

It’s no surprise, I hope, that lhs stands for “left-hand side.”

 I highlight parts of code or parts of comments to draw your attention to them.

In the code above, I’ve highlighted the declaration of rhs and the part of the

comment noting that rhs is an lvalue.

 I use “…” to indicate “other code could go here.” This narrow ellipses is differ-

ent from the wide ellipsis (“...”) that’s used in the source code for C++11’s

variadic templates. That sounds confusing, but it’s not. For example:

template<typename... Ts> // these are C++

void processVals(const Ts&... params) // source code

{ // ellipses

… // this means "some

// code goes here"

}

Page 7

The declaration of processVals shows that I use typename when declaring

type parameters in templates, but that’s merely a personal preference; the

keyword class would work just as well. On those few occasions where I show

code excerpts from a C++ Standard, I declare type parameters using class, be-

cause that’s what the Standards do.

When an object is initialized with another object of the same type, the new object

is said to be a copy of the initializing object, even if the copy was created via the

move constructor. Regrettably, there’s no terminology in C++ that distinguishes

between an object that’s a copy-constructed copy and one that’s a move-

constructed copy:

void someFunc(Widget w); // someFunc's parameter w

// is passed by value

Widget wid; // wid is some Widget

someFunc(wid); // in this call to someFunc,

// w is a copy of wid that's

// created via copy construction

someFunc(std::move(wid)); // in this call to SomeFunc,

// w is a copy of wid that's

// created via move construction

Copies of rvalues are generally move-constructed, while copies of lvalues are typi-

cally copy-constructed. An implication is that if you know only that an object is a

copy of another object, it's not possible to say how expensive it was to construct

the copy. In the code above, for example, there’s no way to say how expensive it is

to create the parameter w without knowing whether rvalues or lvalues are passed

to someFunc. (You’d also have to know the cost of moving and copying Widgets.)

In a function call, the expressions passed at the call site are the function’s argu-

ments. The arguments are used to initialize the function’s parameters. In the first

call to someFunc above, the argument is wid. In the second call, the argument is

std::move(wid). In both calls, the parameter is w. The distinction between argu-

ments and parameters is important, because parameters are lvalues, but the ar-

guments with which they are initialized may be rvalues or lvalues. This is especial-

ly relevant during the process of perfect forwarding, whereby an argument passed

剩余43页未读，继续阅读

Cu2S

粉丝: 6
资源: 11

Effective Modern C++精华概览

sampler-1.1.0-windows-amd64.exe

jmeter-ssh-sampler-master.zip

一文弄懂Pytorch的DataLoader, DataSet, Sampler之间的关系

data_sampler

Sampler-Machine

Gibbs_sampler

cesium-sampler

sampler-scaffold

Sampler_Taller

iOS7Sampler

最新资源