Effective Modern C++. 42 Specific Ways to Improve Your Use of C++11 and C++14

Autor:: Scott Meyers

Effective Modern C++. 42 Specific Ways to Improve Your Use of C++11 and C++14 Scott Meyers - okladka książki

Wydawnictwo:: O'Reilly Media (Z chęcią przeczytam książkę w języku polskim)
Ocena:: Bądź pierwszym, który oceni tę książkę
Stron:: 334
Dostępne formaty:: ePub

Mobi

Ebook 186,15 zł najniższa cena z 30 dni

~~229,00 zł~~ (-15%)
194,65 zł

Dodaj do koszyka lub Kup na prezent Kup 1-kliknięciem

186,15 zł najniższa cena z 30 dni

Przenieś na półkę

Do przechowalni

Najczęściej kupowane razem

Effective Modern C++. 42 Specific Ways to Improve Your Use of C++11 and C++14 Scott Meyers

The Modern C++ Challenge. Become an expert programmer by solving real-world problems Marius Bancila, Scott Meyers

Skuteczny nowoczesny C++ Scott Meyers

Cena zestawu: 355.12 zł

Zyskujesz: 62.67 zł (-15%)

Dodaj do koszyka

Coming to grips with C++11 and C++14 is more than a matter of familiarizing yourself with the features they introduce (e.g., auto type declarations, move semantics, lambda expressions, and concurrency support). The challenge is learning to use those features effectively—so that your software is correct, efficient, maintainable, and portable. That’s where this practical book comes in. It describes how to write truly great software using C++11 and C++14—i.e. using modern C++.

Topics include:

The pros and cons of braced initialization, noexcept specifications, perfect forwarding, and smart pointer make functions
The relationships among std::move, std::forward, rvalue references, and universal references
Techniques for writing clear, correct, effective lambda expressions
How std::atomic differs from volatile, how each should be used, and how they relate to C++'s concurrency API
How best practices in "old" C++ programming (i.e., C++98) require revision for software development in modern C++

Effective Modern C++ follows the proven guideline-based, example-driven format of Scott Meyers' earlier books, but covers entirely new material.

"After I learned the C++ basics, I then learned how to use C++ in production code from Meyer's series of Effective C++ books. Effective Modern C++ is the most important how-to book for advice on key guidelines, styles, and idioms to use modern C++ effectively and well. Don't own it yet? Buy this one. Now".

-- Herb Sutter, Chair of ISO C++ Standards Committee and C++ Software Architect at Microsoft

Wybrane bestsellery

Ebooka "Effective Modern C++. 42 Specific Ways to Improve Your Use of C++11 and C++14" przeczytasz na:

czytnikach Inkbook, Kindle, Pocketbook, Onyx Boox i innych
systemach Windows, MacOS i innych

systemach Windows, Android, iOS, HarmonyOS
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi

Masz pytania? Zajrzyj do zakładki Pomoc »

Audiobooka "Effective Modern C++. 42 Specific Ways to Improve Your Use of C++11 and C++14" posłuchasz:

w aplikacji Ebookpoint na Android, iOS, HarmonyOs
na systemach Windows, MacOS i innych

na dowolonych urządzeniach
i aplikacjach obsługujących format MP3
(pliki spakowane w ZIP)

Masz pytania? Zajrzyj do zakładki Pomoc »

Kurs Video "Effective Modern C++. 42 Specific Ways to Improve Your Use of C++11 and C++14" zobaczysz:

Oceny i opinie klientów: Effective Modern C++. 42 Specific Ways to Improve Your Use of C++11 and C++14 Scott Meyers (0)

Szczegóły książki

ISBN Ebooka:: 978-14-919-0842-6, 9781491908426
Data wydania ebooka :: 2014-11-11 Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@ebookpoint.pl.
Język publikacji:: 1
Rozmiar pliku ePub:: 2.4MB
Rozmiar pliku Mobi:: 5.8MB

Zgłoś erratę

Kategorie

Kliknij, aby zgłosić błędnie przypisaną kategorię »

Informatyka » Programowanie » C++

Spis treści książki

Copyright/Revision History
From the Publisher
- Using Code Examples
- Safari Books Online
- How to Contact Us
Acknowledgments
Introduction
- Terminology and Conventions
- Reporting Bugs and Suggesting Improvements
1. Deducing Types
- Item 1:Understand template type deduction.
  - Case 1: ParamType is a Reference or Pointer, but not a Universal Reference
  - Case 2: ParamType is a Universal Reference
  - Case 3: ParamType is Neither a Pointer nor a Reference
  - Array Arguments
  - Function Arguments
- Item 2:Understand auto type deduction.
- Item 3:Understand decltype.
- Item 4:Know how to view deduced types.
  - IDE Editors
  - Compiler Diagnostics
  - Runtime Output
2. auto
- Item 5:Prefer auto to explicit type declarations.
- Item 6:Use the explicitly typed initializer idiom when auto deduces undesired types.
3. Moving to Modern C++
- Item 7:Distinguish between () and {} when creating objects.
- Item 8:Prefer nullptr to 0 and NULL.
- Item 9:Prefer alias declarations to typedefs.
- Item 10:Prefer scoped enums to unscoped enums.
- Item 11:Prefer deleted functions to private undefined ones.
- Item 12:Declare overriding functions override.
- Item 13:Prefer const_iterators to iterators.
- Item 14:Declare functions noexcept if they wont emit exceptions.
- Item 15:Use constexpr whenever possible.
- Item 16:Make const member functions thread safe.
- Item 17:Understand special member function generation.
4. Smart Pointers
- Item 18:Use std::unique_ptr for exclusive-ownership resource management.
- Item 19:Use std::shared_ptr for shared-ownership resource management.
- Item 20:Use std::weak_ptr for std::shared_ptr-like pointers that can dangle.
- Item 21:Prefer std::make_unique and std::make_shared to direct use of new.
- Item 22:When using the Pimpl Idiom, define special member functions in the implementation file.
5. Rvalue References, Move Semantics, and Perfect Forwarding
- Item 23:Understand std::move and std::forward.
- Item 24:Distinguish universal references from rvalue references.
- Item 25:Use std::move on rvalue references, std::forward on universal references.
- Item 26:Avoid overloading on universal references.
- Item 27:Familiarize yourself with alternatives to overloading on universal references.
  - Abandon overloading
  - Pass by const T&
  - Pass by value
  - Use Tag dispatch
  - Constraining templates that take universal references
  - Trade-offs
- Item 28:Understand reference collapsing.
- Item 29:Assume that move operations are not present, not cheap, and not used.
- Item 30:Familiarize yourself with perfect forwarding failure cases.
  - Braced initializers
  - 0 or NULL as null pointers
  - Declaration-only integral static const and constexpr data members
  - Overloaded function names and template names
  - Bitfields
  - Upshot
6. Lambda Expressions
- Item 31:Avoid default capture modes.
- Item 32:Use init capture to move objects into closures.
- Item 33:Use decltype on auto&& parameters to std::forward them.
- Item 34:Prefer lambdas to std::bind.
7. The Concurrency API
- Item 35:Prefer task-based programming to thread-based.
- Item 36:Specify std::launch::async if asynchronicity is essential.
- Item 37:Make std::threads unjoinable on all paths.
- Item 38:Be aware of varying thread handle destructor behavior.
- Item 39:Consider void futures for one-shot event communication.
- Item 40:Use std::atomic for concurrency, volatile for special memory.
8. Tweaks
- Item 41:Consider pass by value for copyable parameters that are cheap to move and always copied.
- Item 42:Consider emplacement instead of insertion.
Index