Essential C++
Getting started
Literals
Basic type keywords
Operator precedence
Floating point arithmetic
Bit operators
Bit manipulation
Bit fields
Arrays
Flow control
const keyword
Loops
mutable keyword
friend keyword
keywords
Variable declaration keywords
auto keyword
Pointers
Type keywords (class, enum, struct, union)
Classes / structs
std::string
Enumeration
std::atomic<T>
std::vector
std::array
std::pair
std::map
std::unordered_map
std::set and std::multiset
std::any
std::variant
std::optional
std::integer_sequence
std::function
std::forward_list
std::iomanip
Iterators
Basic I/O
File I/O
Streams
Stream manipulators
Metaprogramming
Returning multiple values from a function
References
Polymorphism
Value and reference semantics
Function call by value vs. by reference
Copying vs assignment
Pointers to class / struct members
The this pointer
Smart pointers
Unions
Templates
Namespaces
Function overloading
Operator overloading
Lambdas
Threading
Value categories
Preprocessor
SFINAE
Rule of three, five and zero
RAII
Exceptions
Implementation-defined behavior
Special member functions
Random numbers
Sorting
Regular expressions
Perfect forwarding
Virtual member functions
Undefined behavior
Overload resolution
Move semantics
Pimpl idiom
Copy elision
Fold expressions
Unnamed types
Singleton
ISO C++ Standard
User-defined literals
Type erasure
Memory management
Explicit type conversions
RTTI
Standard library algorithms
Expression templates
Scopes
Atomic types
static assert
constexpr
Date and time with std::chrono
Trailing return type
Function template overloading
Common compile linker errors
Design patterns
Optimizations
Compiling and building
Type traits
One definition rule
Unspecified behavio
Argument dependent name lookup
Attributes
Internationalization
Profiling
Return type covariance
Non-static member functions
Recursion
Callable objects
Constant class member functions
C++ vs. C++ 11 vs C++ 17
Inline functions
Client server examples
Header files
Const correctness
Refactoring techniques
Parameter packs
Iteration
type deduction
C++ 11 memory model
Build systems
Concurrency with OpenMP
Type inference
Resource management
Storage class specifiers
Alignment
Inline variables
Linkage specifications
Curiusly recurring template pattern
Using declaration
Typedef and type aliases
Layout of object types
C incompatibilities
Optimization
Semaphore
Semaphore
Semaphore C 11
Semaphore class in action
Thread synchronization
Debugging
Futures and promises
More undefined behaviors
Mutexes
Recursive mutex
Unit testing
decltype
Digit separators
C++ Containers
Arithmetic meta-programming
Contributors

Semaphore

suggest change
Found a mistake? Have a question or improvement idea? Let me know.

Feedback about page:

Feedback:
Optional: your email if you want me to get back to you:

Semaphore/
Semaphore
Semaphore C 11
Semaphore class in action
Table Of Contents
1 Getting started
2 Literals
3 Basic type keywords
4 Operator precedence
5 Floating point arithmetic
6 Bit operators
7 Bit manipulation
8 Bit fields
9 Arrays
10 Flow control
11 const keyword
12 Loops
13 mutable keyword
14 friend keyword
15 keywords
16 Variable declaration keywords
17 auto keyword
18 Pointers
19 Type keywords (class, enum, struct, union)
20 Classes / structs
21 std::string
22 Enumeration
23 std::atomic<T>
24 std::vector
25 std::array
26 std::pair
27 std::map
28 std::unordered_map
29 std::set and std::multiset
30 std::any
31 std::variant
32 std::optional
33 std::integer_sequence
34 std::function
35 std::forward_list
36 std::iomanip
37 Iterators
38 Basic I/O
39 File I/O
40 Streams
41 Stream manipulators
42 Metaprogramming
43 Returning multiple values from a function
44 References
45 Polymorphism
46 Value and reference semantics
47 Function call by value vs. by reference
48 Copying vs assignment
49 Pointers to class / struct members
50 The this pointer
51 Smart pointers
52 Unions
53 Templates
54 Namespaces
55 Function overloading
56 Operator overloading
57 Lambdas
58 Threading
59 Value categories
60 Preprocessor
61 SFINAE
62 Rule of three, five and zero
63 RAII
64 Exceptions
65 Implementation-defined behavior
66 Special member functions
67 Random numbers
68 Sorting
69 Regular expressions
70 Perfect forwarding
71 Virtual member functions
72 Undefined behavior
73 Overload resolution
74 Move semantics
75 Pimpl idiom
76 Copy elision
77 Fold expressions
78 Unnamed types
79 Singleton
80 ISO C++ Standard
81 User-defined literals
82 Type erasure
83 Memory management
84 Explicit type conversions
85 RTTI
86 Standard library algorithms
87 Expression templates
88 Scopes
89 Atomic types
90 static assert
91 constexpr
92 Date and time with std::chrono
93 Trailing return type
94 Function template overloading
95 Common compile linker errors
96 Design patterns
97 Optimizations
98 Compiling and building
99 Type traits
100 One definition rule
101 Unspecified behavio
102 Argument dependent name lookup
103 Attributes
104 Internationalization
105 Profiling
106 Return type covariance
107 Non-static member functions
108 Recursion
109 Callable objects
110 Constant class member functions
111 C++ vs. C++ 11 vs C++ 17
112 Inline functions
113 Client server examples
114 Header files
115 Const correctness
116 Refactoring techniques
117 Parameter packs
118 Iteration
119 type deduction
120 C++ 11 memory model
121 Build systems
122 Concurrency with OpenMP
123 Type inference
124 Resource management
125 Storage class specifiers
126 Alignment
127 Inline variables
128 Linkage specifications
129 Curiusly recurring template pattern
130 Using declaration
131 Typedef and type aliases
132 Layout of object types
133 C incompatibilities
134 Optimization
135 Semaphore
136 Thread synchronization
137 Debugging
138 Futures and promises
139 More undefined behaviors
140 Mutexes
141 Recursive mutex
142 Unit testing
143 decltype
144 Digit separators
145 C++ Containers
146 Arithmetic meta-programming
147 Contributors