C++11新特性：高效现代编程实践与提升

需积分: 10 177 浏览量更新于2024-07-18 收藏 5.74MB PDF 举报

本资源主要聚焦于C++11的新特性，详细介绍了如何在现代C++编程中有效利用这些革新特性来提升代码质量。以下是章节概览及关键知识点： 1. **章节标题：类型推导**（Chapter 1: Deducing Types） - **知识点1：自动类型推导（Item 1）** - 学习理解编译器如何自动推断变量或函数参数的类型，这可以简化代码，减少显式类型声明的需要。 - **知识点2：decltype** - decltype关键字用于获取表达式的类型，这对于处理模板、返回类型或函数内部临时对象的类型非常有用。 2. **章节：auto关键字的使用**（Chapter 2: auto） - **知识点5：推荐auto代替显式类型声明** - 使用auto可以让编译器自动推断变量类型，提高可读性和简洁性。 - **知识点9：带类型初始化idiom** - 明确地指定初始化列表与auto配合，有助于避免类型歧义。 3. **C++98到C++11和C++14的转变** - **知识点11：区分()构造和{}初始化** - 在创建对象时，了解何时使用()和{}的不同语法，以确保正确性和性能。 - **知识点12：nullptr替代0和NULL** - 使用nullptr作为空指针常量，有助于避免潜在的类型错误。 - **知识点13：alias declaration优于typedef** - 提倡使用alias declaration，它提供了更强的类型安全性。 4. **其他优化建议** - **知识点14：范围枚举取代无作用域枚举** - 为枚举类型提供作用域，减少潜在的命名冲突和混淆。 - **知识点15：删除函数而非保留私有未定义** - 删除不希望用户调用的函数，比使其成为私有的未定义行为更为清晰。 - **知识点16：声明重载函数明确表示覆盖** - 提供明确的override标识符，确保正确继承行为。 5. **面向对象编程的最佳实践** - **知识点17：const成员函数与线程安全** - 当可能时，使成员函数const，以提高并发环境下的安全性。 - **知识点18：noexcept函数声明** - 提倡使用noexcept来告知编译器函数是否可能导致异常，增强异常处理。 6. **性能优化技巧** - **知识点19：考虑值传递和移动语义** - 对于轻量级对象，优先选择值传递，以利用移动构造和赋值的高效性。 - **知识点20：考虑内存管理优化** - 推荐使用emplace代替insert操作，减少拷贝和分配开销。这些知识点旨在帮助C++开发者更好地理解和利用C++11的新特性，从而编写出更高效、易读和可维护的代码。通过遵循这些最佳实践，可以提升代码质量和开发效率。

Page 15

If param were a pointer (or a pointer to const) instead of a reference, things

would work essentially the same way:

template<typename T>

void f(T* param); // param is now a pointer

int x = 27; // as before

const int *px = &x; // px is a ptr to a read-only view of x

f(&x); // T is int, param's type is int*

f(px); // T is const int,

// param's type is const int*,

At this point, you may find yourself yawning and nodding off, because C++’s type

deduction rules work so naturally for reference and pointer parameters, seeing

them in written form is really dull. Everything’s just obvious! Which is exactly

what you want in a type deduction system.

Case 2: ParamType is a Universal Reference

Things are less obvious for templates taking universal reference parameters (i.e.,

“T&&” parameters), because lvalue arguments get special treatment. The complete

story is told in Item 26, but here’s the headline version:

 If expr is an lvalue, both T and ParamType are deduced to be lvalue refer-

ences.

 If expr is an rvalue, the usual type deduction rules apply.

For example:

template<typename T>

void f(T&& param); // param is now a universal reference

int x = 27; // as before

const int cx = x; // as before

const int& rx = x; // as before

f(x); // x is lvalue, so T is int&,

// param's type is also int&

f(cx); // cx is lvalue, so T is const int&,

// param's type is also const int&

Page 17

Note that even though cx and rx represent const values, param isn’t const. That

makes sense. param is an object that’s completely independent of cx and rx—a

copy of cx or rx. The fact that cx and rx can’t be modified says nothing about

whether param can be. That’s why expr’s constness (if any) is ignored when de-

ducing a type for param: just because expr can’t be modified doesn’t mean that a

copy of it can’t be.

It’s important to recognize that const is ignored only for by-value parameters. As

we’ve seen, for parameters that are references-to- or pointers-to-const, the con-

stness of expr is preserved during type deduction. But consider the case where

expr is a const pointer to a const object, and expr is passed to a by-value param:

template<typename T>

void f(T param); // param is still passed by value

const char* const ptr = // ptr is const pointer to const object

"Fun with pointers";

f(ptr); // pass arg of type const char * const

Here, the const to the right of the asterisk declares ptr to be const: ptr can't be

made to point to a different location, nor can it be set to null. (The const to the left

of the asterisk says that what ptr points to—the character string—is const, hence

can't be modified.) When ptr is passed to f, the bits making up the pointer are

copied into param. As such, the pointer itself (ptr) will be passed by value. In accord

with the type deduction rule for by-value parameters, the constness of ptr will be

ignored, and the type deduced for param will be const char*, i.e., a modifiable

pointer to a const character string. The constness of what ptr points to is pre-

served during type deduction, but the constness of ptr itself is ignored when

copying it to create the new pointer, param.

Array Arguments

That pretty much covers it for mainstream template type deduction, but there’s a

sidestream case that is worth knowing about. It’s that array types are different

from pointer types, even though they sometimes seem to be interchangeable. A

primary contributor to this illusion is that, in many contexts, an array decays into a

pointer to its first element. This decay is what permits code like this to compile:

剩余318页未读，继续阅读

wh_

粉丝: 13
资源: 2

C++11新特性：高效现代编程实践与提升

精通Modern C++：Scott Meyers的编程指南

Effective Modern C++实践指南：提升C++11与C++14使用技巧

使用C++11和C++14的高效编程实践：Effective Modern C++

Effective_Modern_C的书籍代码

Effective Modern C++ 原版pdf by Meyers

Effective.Modern.C++.en_C++_effectivemodern_

Effective Modern C++

effective modern cpp

effective modern c++

effective C++ modern

最新资源