Muutke küpsiste eelistusi

E-raamat: C++17 Standard Library Quick Reference: A Pocket Guide to Data Structures, Algorithms, and Functions

,
Teised raamatud teemal:
  • Formaat - PDF+DRM
  • Hind: 49,39 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.
C++17 Standard Library Quick Reference: A Pocket Guide to Data Structures, Algorithms, and FunctionsSuurem pilt
Teised raamatud teemal:

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

This quick reference is a condensed guide to the essential data structures, algorithms, and functions provided by the C++17 Standard Library. It does not explain the C++ language or syntax, but is accessible to anyone with basic C++ knowledge or programming experience. Even the most experienced C++ programmer will learn a thing or two from it and find it a useful memory-aid. 

It is hard to remember all the possibilities, details, and intricacies of the vast and growing Standard Library. This handy reference guide is therefore indispensable to any C++ programmer. It offers a condensed, well-structured summary of all essential aspects of the C++ Standard Library. No page-long, repetitive examples or obscure, rarely used features. Instead, everything you need to know and watch out for in practice is outlined in a compact, to-the-point style, interspersed with practical tips and well-chosen, clarifying examples. 

This new edition is updated to include all Standard Library changes in C++17, including the new vocabulary types std::string_view, any, optional, and variant; parallel algorithms; the file system library; specialized mathematical functions; and more.

What You Will Learn
  • Gain the essentials that the C++ Standard Library has to offer
  • Use containers to efficiently store and retrieve your data
  • Inspect and manipulate your data with algorithms 
  • See how lambda expressions allow for elegant use of algorithms
  • Discover what the standard string class provides and how to use it
  • Write localized applications
  • Work with file and stream-based I/O
  • Prevent memory leaks with smart pointers
  • Write safe and efficient multi-threaded code using the threading libraries

Who This Book Is For

All C++ programmers, irrespective of their proficiency with the language or the Standard Library. A secondary audience is developers who are new to C++, but not new to programming, and who want to learn more about the C++ Standard Library in a quick, condensed manner.

About the Authors xv
About the Technical Reviewer xvii
Introduction xix
Chapter 1 Numerics and Math 1(28)
Common Mathematical Functions <cmath>
1(4)
Basic Functions
1(1)
Exponential and Logarithmic Functions
2(1)
Power Functions
2(1)
Trigonometric and Hyperbolic Functions
3(1)
Integral Rounding of Floating-Point Numbers
3(1)
Floating-Point Manipulation Functions
3(1)
Classification and Comparison Functions
4(1)
gcd/lcm C++17 <numeric>
4(1)
Error Handling
5(1)
Special Mathematical Functions C++17 <cmath>
5(4)
Besse! Functions
6(1)
Polynomials
7(1)
Elliptic Integrals
7(1)
Exponential Integrals
8(1)
Error Functions
8(1)
Gamma Functions
8(1)
Beta Functions
9(1)
Zeta Functions
9(1)
Minimum, Maximum, and Clamping <algorithm>
9(1)
Fixed-Width Integer Types <cstdint>
10(1)
Arithmetic Type Properties <limits>
11(2)
Complex Numbers <complex>
13(1)
Compile-Time Rational Numbers <ratio>
14(1)
Random Numbers <random>
15(8)
Random Number Generators
15(3)
Random Number Distributions
18(5)
Numeric Arrays <valarray>
23(6)
std::slice
24(1)
std::gslice
25(1)
std::mask_array
26(1)
std::indirect_array
27(2)
Chapter 2 General Utilities 29(44)
Moving, Forwarding, Swapping <utility>
29(4)
Moving
29(2)
Forwarding
31(1)
Swapping and Exchanging
32(1)
Pairs and Tuples
33(1)
Pairs <utility>
33(2)
Tuples <tuple>
34(1)
std::byte C++17 <cstddef>
35(1)
Relational Operators <utility>
36(1)
Smart Pointers <memory>
36(6)
Exclusive Ownership Pointers
36(3)
Shared Ownership Pointers
39(3)
Function Objects <functional>
42(5)
Reference Wrappers
43(1)
Predefined Functors
43(1)
Binding Function Arguments
44(1)
Negating a Callable C++17
45(1)
Generic Function Wrappers
45(1)
Functors for Class Members
46(1)
Initializer Lists <initializer_list>
47(1)
Vocabulary Types C++17
48(8)
std::optional <optional>
48(2)
std::variant <variant>
50(5)
std::any <any>
55(1)
Date and Time Utilities <chrono>
56(6)
Durations
57(1)
Time Points
58(1)
Clocks
59(1)
C-Style Date and Time Utilities <ctime>
60(2)
Type Utilities
62(9)
Runtime Type Identification <typeinfo>, <typeindex>
62(1)
Type Traits <type_traits>
63(7)
Type Operations <utility>
70(1)
Generic Utilities
71(2)
std::invoke C++17 <functional>
71(1)
std::addressof <memory>
72(1)
Chapter 3 Containers 73(40)
Iterators <iterator>
73(3)
Iterator Tags
74(1)
Non-member Functions to Get Iterators
75(1)
Non-member Operations on Iterators
76(1)
Sequential Containers
76(13)
std::vector <vector>
76(7)
std::deque <deque>
83(1)
std::array <array>
84(1)
std::list and std::forward_list <list>, <forward_list>
84(2)
Sequential Containers Reference
86(3)
std::bitset <bitset>
89(2)
Complexity
90(1)
Reference
90(1)
Container Adaptors
91(2)
std::queue <queue>
91(1)
std::priority_queue <queue>
91(1)
std::stack <stack>
92(1)
Example
92(1)
Reference
93(1)
Ordered Associative Containers
93(10)
std::map <map>
94(1)
Inserting in a Map
95(3)
std::multimap <map>
98(1)
std::set and std::multiset <set>
98(1)
Order of Elements
98(1)
Searching
99(1)
Moving Nodes Between Containers C++17
100(1)
Merging Containers amp
100(1)
Complexity
101(1)
Reference
101(2)
Unordered Associative Containers <unordered_map>, <unordered_set>
103(5)
Hash Map
104(1)
Template Type Parameters
104(1)
Hash Functions
104(2)
Complexity
106(1)
Reference
106(2)
Allocators <memory>
108(5)
Polymorphic Allocators C++17 <memory_resource>
108(3)
Allocators for Multilevel Containers <scoped_allocator>
111(2)
Chapter 4 Algorithms 113(28)
Input and Output Iterators
113(1)
General Guidelines
114(1)
Algorithm Arguments
114(1)
Terminology
115(1)
Algorithms <algorithm>
115(17)
Applying a Function to a Range
115(2)
Checking for the Presence of Elements
117(1)
Finding Elements
117(1)
Finding Min/Max Elements
118(1)
Binary Search
119(1)
Subsequence Search
120(1)
Sequence Comparison
121(1)
Generating Sequences
122(1)
Copy, Move, Swap
123(1)
Removing and Replacing
124(1)
Reversing and Rotating
125(1)
Partitioning
126(1)
Sorting
127(1)
Sampling and Shuffling
128(1)
Operations on Sorted Ranges
129(1)
Permutation
130(1)
Heaps
131(1)
Numeric Algorithms <numeric>
132(3)
Reductions
132(1)
Inner Products
133(1)
Prefix Sums
134(1)
Element Differences
135(1)
Algorithms for Uninitialized Memory <memory>
135(1)
Parallel Algorithms C++17 <execution>
136(2)
Parallel Execution
137(1)
Parallel Unsequenced Execution
138(1)
Iterator Adaptors <iterator>
138(3)
Chapter 5 Input/Output 141(48)
Input/Output with Streams
141(12)
Helper Types dos>
142(1)
Formatting Methods (std::ios_base) dos>
143(2)
I/O Manipulators dos>, <iomanip>
145(1)
Example
146(1)
std::ios dos>
147(2)
std::ostream <ostream>
149(2)
std::istream <istream>
151(2)
std::iostream <istream>
153(1)
String Streams <sstream>
153(2)
Example
154(1)
File Streams <fstream>
155(1)
Example
156(1)
Streaming Custom Types
156(4)
Custom << and >> Operators
156(1)
Custom I/O Manipulators dos>
157(3)
Stream Iterators <iterator>
160(1)
std::ostream_iterator
160(1)
std::istream_iterator
160(1)
Stream Buffers <streambuf>
161(1)
File Systems <filesystem>
162(18)
Files, Paths, and Pathnames
162(1)
Error Reporting
163(1)
The path Class
164(4)
File Links
168(1)
Path Normalization
169(1)
The Current Working Directory
170(1)
Absolute and Relative Paths
170(2)
Comparing Paths
172(1)
File Status
172(4)
Creating, Copying, Deleting, and Renaming
176(1)
File Sizes and Free Space
177(1)
Directory Listing
178(2)
C-Style File Utilities <cstdio>
180(1)
C-Style Output and Input <cstdio>
181(8)
std::printf() Family
181(4)
std::scanf() Family
185(4)
Chapter 6 Characters and Strings 189(42)
Strings <string>
189(5)
Searching in Strings
190(1)
Modifying Strings
191(1)
Constructing Strings
192(1)
String Length
192(1)
Copying (Sub)Strings
193(1)
Comparing Strings
193(1)
String Views C++17 <string_view>
194(1)
Character Classification <cctype>, <cwctype>
195(2)
Character-Encoding Conversion <locale>, <codecvt>
197(3)
Localization <locale>
200(14)
Locale Names
200(1)
The Global Locale
201(1)
Basic std::locale Members
202(1)
Locale Facets
202(8)
Combining and Customizing Locales
210(3)
C Locales <clocale>
213(1)
Regular Expressions <regex>
214(12)
The ECMAScript Regular Expression Grammar
214(2)
Regular Expression Objects
216(2)
Matching and Searching Patterns
218(3)
Match Iterators
221(2)
Replacing Patterns
223(3)
Numeric Conversions
226(5)
Convenient Conversion Functions <string>
227(2)
High-Performance Conversion Functions C++17 <charconv>
229(2)
Chapter 7 Concurrency 231(26)
Threads <thread>
231(3)
Launching a New Thread
231(1)
A Thread's Lifetime
232(1)
Thread Identifiers
232(1)
Utility Functions
233(1)
Exceptions
233(1)
Futures <future>
234(4)
Return Objects
234(1)
Providers
235(2)
Exceptions
237(1)
Mutual Exclusion <mutex>
238(7)
Mutexes and Locks
238(1)
Mutex Types
239(2)
Lock Types
241(3)
Locking Multiple Mutexes
244(1)
Exceptions
244(1)
Calling a Function Once <mutex>
245(1)
Condition Variables <condition_variable>
246(2)
Waiting for a Condition
246(1)
Notification
247(1)
Exceptions
248(1)
L1 Data Cache Line Size C++17 <new>
248(1)
Synchronization
249(1)
Atomic Operations <atomic>
250(7)
Atomic Variables
250(5)
Atomic Flags
255(1)
Non-member Functions and Macros
255(1)
Fences
255(2)
Chapter 8 Diagnostics 257(14)
Assertions <cassert>
257(1)
Exceptions <exception>, <stdexcept>
258(1)
Exception Pointers <exception>
259(1)
Nested Exceptions <exception>
260(2)
System Errors <system_error>
262(2)
std::error_category
263(1)
std::error_code
263(1)
std::error_condition
264(1)
C Error Numbers <cerrno>
264(1)
Failure Handling <exception>
265(6)
std::uncaught_exceptions() C++17
265(1)
std::terminate()
266(5)
Appendix: Standard Library Headers 271(8)
Numerics and Math (Chapter 1)
271(1)
General Utilities (Chapter 2)
272(1)
Containers (Chapter 3)
273(1)
Algorithms (Chapter 4)
274(1)
Input/Output (Chapter 5)
274(1)
Characters and Strings (Chapter 6)
275(1)
Concurrency (Chapter 7)
276(1)
Diagnostics (Chapter 8)
277(1)
The C Standard Library
277(2)
Index 279
Marc Gregoire is a software engineer from Belgium. He graduated from the University of Leuven, Belgium, with a degree in Burgerlijk ingenieur in de computer wetenschappen (equivalent to Master of Science in engineering in computer science). The year after, he received the cum laude degree of master in artificial intelligence at the same university. After his studies, Marc started working for a software consultancy company called Ordina Belgium. As a consultant, he worked for Siemens and Nokia Siemens Networks on critical 2G and 3G software running on Solaris for telecom operators. This required working in international teams stretching from South America and USA to EMEA and Asia. Now, Marc is working for Nikon Metrology on industrial 3D laser scanning software. His main expertise is C/C++, and specifically Microsoft VC++ and the MFC framework. He has experience in developing C++ programs running 24x7 on Windows and Linux platforms; for example, KNX/EIB home automation software. Next to C/C++, Marc also likes C# and uses PHP for creating web pages. Since April 2007, he received the yearly Microsoft MVP (Most Valuable Professional) award for his Visual C++ expertise. Marc is the founder of the Belgian C++ Users Group, author of Professional C++ and a member on the CodeGuru forum (as Marc G). 









Peter Van Weert is a Belgian software engineer, whose main interests and expertise are programming languages, algorithms, and data structures. He received his master of science in computer science summa cum laude with congratulations of the Board of Examiners from the University of Leuven. In 2010, he completed his PhD thesis on the design and efficient compilation of rule based programming languages at the declarative programming languages and artificial intelligence department of the same university. During his doctoral studies, he was a teaching assistant for object-oriented programming (Java), software analysis and design, and declarative programming. After graduating, Peter joined Nikon Metrology to work on large-scale, industrial application software in the area of 3D laser scanning and point cloud inspection. At Nikon, he has mastered C++, refactoring and debugging very large code bases, and has gained further proficiency in all aspects of the software development process, including the analysis of functional and technical requirements, and agile and scrum-based project and team management. In his spare time, he has co-authored two award-winning Windows 8 apps, and is a regular speaker at and board member of the Belgian C++ Users Group.
Lisainfo e-raamatute kohta Lisainfo e-raamatute kohta
Püsilink: https://www.kriso.ee/db/97814842492392e.html
Märksõnad: