Core concepts of C++

Restricted © 2017 Mentor Graphics Corporation
1
Core concepts of C++
Martin Ayvazyan
22/01/2019
Senior software/machine learning engineer

Contents
 Memory management
 Templates, Type deduction – decltype, auto
 R-value references, Universal references, Move semantics, Perfect
Forwarding
 Smart pointers, STL
 Concurrency – multitasking, multithreading (not completed yet)
2

Memory management
 Intel 4004 (1971) - 4 bit
 Intel 8008 (1978) - 8 bit
 Intel 8086 (1978) - 16 bit
 Intel 80286 (1982) – 16 bit + protected mode
 Intel 80386 (1985) – 32 bit + protected mode
3

Memory management
 Memory addressing
• Real mode
• Linear addressing
• Segmentation
• Protected mode
• Segmentation
• Paging
4

Memory management
 Memory addressing - real mode
All real mode memory addresses consist of a segment address
plus an offset address:
• the segment address (in one of the segment registers) defines
the beginning address of any 64Kb memory segment
• the offset address selects a location within the 64K byte
memory segment
ϒ = α ∗ 16 + β where αϵ{𝑐𝑠, 𝑠𝑠, 𝑑𝑠, 𝑒𝑠, 𝑔𝑠, 𝑓𝑠}
5

Memory management
 Memory addressing – protected mode
• From logic address  Linear address (32 bit)
• If paging is disabled  Linear address  Physical address
Assembly of segment register in protected mode:
6
15 3 2 1 0
PRLTIIndex
Selector
TI – table index, if TI==0  GDT, if TI==1 LDT
PRL – request priority level (in case of CS CPL)

Memory management
 Memory addressing – protected mode (TI=0)
7
GDTR
GDT
Descriptor
Index
byte5 byte4 byte3 byte2 byte1 byte0
Address Limit
Address+Index*8

Memory management
 Memory addressing
• Protected mode
The protected mode processors use a look up table to compute
the physical address. Memory addressing is based on ‘Segment
Descriptors’ that define a memory-region and assign its
properties.
8
Type and
access-rights
Segment-
Base[23..16]
Word 3 Word 2
Segment-Base[15..0] Segment-Limit[15..0]
Word 1 Word 0
Segment-base
[31…24]
FLAGS(G, DB, …)

Memory management
 Memory addressing - Protected mode
• Type and access-rights
9
P DPL S X C/D R/W A
P = Present (1=yes, 0=no)
DPL = Descriptor Privilege Level (00=supervisor, 11=user)
S = System-segment (0=yes, 1=no)
X = executable: 1=yes (i.e., code-segment), 0=no (i.e., data-segment)
C/D = Conforming code (1=yes, 0=no) when X-bit equals 1
expands-Down (1=yes, 0=no) when X-bit equals 0
R/W = Readable (1=yes, 0=no) when X-bit equals 1
Writable (1=yes, 0=no) when X-bit equals 0
A = segment has been Accessed by the CPU (1=yes, 0=no)

Memory management
 Memory addressing - Protected mode
• Type and access-rights
10
S =1
S=0
I=0 E W
I=1 C R
TYPE(gates)
A
P – is the segment in memory
DPL – description privilege level
S – system descriptor(=1) or no(=0)
I – data segment(=0), code segment(=1)
E – common data segment(0)
W – is writable (if (E) assert(W==1);)
A – Access flag
C – conform(=1), non-*(=0) segment
R – Code segment can be read
DPLP

Memory management
 Paging / Virtual memory management
11
CR3
PD
PDE
PT
PTE
α β ϒ
linear address
Page

Memory management
 Computer memory hierarchy
12
Registers
Processor cache(L1, L2, …)
RAM
Hard drives
1 ns.
2 ns.
10 ns.
10 ms.
< 1Kb
4 Mb
512-2048 Mb
200-1000Gb

Memory management
 C++ memory storages (in general)
— Static
— Heap
— Stack
13

Memory management
 C++ memory storages – static memory storage
Possible problems of static objects initialization:
— static initialization order ‘fiasco’ problem – here we have a 50%-50%
chance of corrupting the program(if y would be constructed before x).
14
// f1.cpp
#include “T1.h”
T1 obj1;
// f2.cpp
#include “T2.h”
T2 obj2;
// T2.cpp
#include “T2.h”
T2::T2{
x.do_dmth();
}

Memory management
 C++ memory storages – static memory storage
Solution for the problem - Construct On First Use Idiom - i.e. replace
the namespace-scope/global T1 object with a namespace-
scope/global function f_obj() that returns the Fred object by
reference:
15
// f1.cpp
T1& get()
{
static T1* ptr = new T1();
return *ptr;
}
// f1.cpp
T1& get()
{
static T1 ref;
return ref;
}
?
need to be 100% sure our static object:
(a) gets constructed prior to its first use
(b) doesn’t get destructed until after its last use.

Memory management
 C++ memory storages – heap memory storage
— new operator to allocate an object in memory
— delete operator to deallocate an allocated object
Try to avoid heap memory fragmentations as much as possible.
Use placement new if you have enough knowledge about it:
16
void fn()
{
char memory[sizeof(T)];
void* p = memory;
T* f = new(p) T();
// do smth.
}

Memory management
 C++ memory storages – heap memory storage / placement new
17
void fn()
{
void* p = memory;
T* f = new(p) T();
// do smth.
}
void fn()
{
void* p = memory;
T* f = new(p) T();
// do smth.
f->~T();
}

Memory management
 C++ memory storages – ‘stack’ memory storage
— Stack variables are local in nature.
— There is a limit (varies with OS) on the size of variables that can be stored
on the stack.
— The stack grows and shrinks as functions push and pop local variables
— There is no need to manage the memory yourself, variables are allocated
and freed automatically
— Stack variables only exist while the function that created them, is running
18

Memory management
 C++ memory storages – stack vs heap
19
Stack Heap
very fast access (relatively) slower access
don't have to explicitly de-allocate variables no guaranteed efficient use of space
limit on stack size (OS-dependent) no limit on memory size
local variables only variables can be accessed globally
space is managed efficiently by CPU,
memory will not become fragmented
allocated memory must be managed
variables cannot be resized variables can be resized
using realloc()

Memory management
 Structure Padding
• Architecture of a computer processor is such a way that it can read 1 word
(4 byte in 32 bit processor) from memory at a time.
• To make use of this advantage of processor, data are always aligned as 4
bytes package which leads to insert empty addresses between other
member’s address.
• Because of this size of the structure is always not same as what we think.
• In order to align the data in memory, one or more empty bytes are
inserted between memory addresses which are allocated for other
structure members while memory allocation.
20

Memory management
 Structure Padding
21
struct A {};
struct B
{bool b};
struct C
{bool b; int x;};
struct C
{bool b1, b2; int x;};
struct C
{bool b1; int x; bool b2};
[](){};
[x=true, y=2, z= true](){};
[x=true, y=2, z= true](){};
std::tuple<bool, int>
std::tuple<bool, bool,
int>
std::tuple<bool,int,
bool>
std::function<void()>

Memory management
 False sharing
22
class T
{ int x1, x2;};
static T obj;
int f()
{
int sum=0;
for (i=0;i<131313; ++i) sum +=obj.x1;
return sum;
}
void g()
{
for (i=0;i<131313; ++i) ++obj.x2;
}
When f and g are running concurrently
sum may need re-read x1 from main
memory event though concurrent
modification of x2 does not affect on
x1.

Memory management
 False sharing
23

Memory management
 Value categories in C++
Each C++ expression is characterized by two independent properties: a type
and a value. Each expression has some non-reference type and each
expression belongs to a value category.
• C++98
An expression is either an:
• lvalue – occupies some identifiable location in memory
• rvalue – !lvalue
• C++11
• lvalue
• rvalue
• xvalue
• prvalue
• glvalue
24

Memory management
 Value categories in C++11
Two properties of expressions
• Can be moved from
Move constructor, move ‘=‘operator, or another function overload that implements move
semantics can bind to the expression.
• Has identity
It’s possible to determine whether the expression refers to the same entity as another
expression, such as by comparing addresses of the objects or the functions they
identify(obtained directly or indirectly).
25

Memory management
 Value categories in C++11
• glvalue - has identity. Is either lvalue or xvalue.
• rvalue – can be moved from. Is either prvalue or xvalue.
• lvalue – has identity and can’t be moved from. { the name of a variable, a
function, function call whose return type is lvalue(++i), assignment and
compound assignment, built-in comma expression where the second
operand is lvalue, a ? b : c(lvalues), string literal, static_cast<T&> }
• xvalue – has identity and can be moved from. { std::move,
static_cast<T&&>, the member of object like a.m(where a is an rvalue and
m is non-static data member of non-reference type) }
• prvalue- does not identity and can’t be moved from. {literal, i++, expr.
Whose return type non-ref, built-in address-of expression, static_cast<int>
}
26

Memory management
 Value categories
27
expression
rvalue glvalue
prvalue xvalue lvalue

Memory management
 Bitfields
28
struct S {
bool b1: 1,
bool b2: 1,
…
bool b8: 1
};
union {
struct S {
bool b1: 1,
bool b2: 1,
…
bool b8: 1
};
bool dummy;
};

Memory management
 Things need to attention
— const_cast
— (a+b)-c != a+(b-c)
— stack and realloc
— using compile-time unknown expression to define size of stak’s objects
— taking address of a bitfield
— size of an array like arr[N] known at compile time! (T(&)[N])
29

Templates / Type deduction – auto and decltype
 Type deduction for templates
MyT x;
const MyT& y = x;
𝑡𝑒𝑚𝑝𝑙𝑎𝑡𝑒 < 𝑐𝑙𝑎𝑠𝑠 𝑇 > 𝑣𝑜𝑖𝑑 𝑓 𝑇2 𝑎𝑟𝑔 …
— 𝑡𝑒𝑚𝑝𝑙𝑎𝑡𝑒 < 𝑐𝑙𝑎𝑠𝑠 𝑇 > 𝑣𝑜𝑖𝑑 𝑓 𝑇 𝑎𝑟𝑔 …  f(x), f(y) T2, T2 ?
— 𝑡𝑒𝑚𝑝𝑙𝑎𝑡𝑒 < 𝑐𝑙𝑎𝑠𝑠 𝑇 > 𝑣𝑜𝑖𝑑 𝑓 𝑇& 𝑎𝑟𝑔 …  f(x), f(y) T2, T2 ?
— 𝑡𝑒𝑚𝑝𝑙𝑎𝑡𝑒 < 𝑐𝑙𝑎𝑠𝑠 𝑇 > 𝑣𝑜𝑖𝑑 𝑓 𝑐𝑜𝑛𝑠𝑡 𝑇& 𝑎𝑟𝑔 …  f(x), f(y) T2, T2 ?
— 𝑡𝑒𝑚𝑝𝑙𝑎𝑡𝑒 < 𝑐𝑙𝑎𝑠𝑠 𝑇 > 𝑣𝑜𝑖𝑑 𝑓 𝑇&& 𝑎𝑟𝑔 …  f(x), f(y) T2, T2 ?
— 𝑡𝑒𝑚𝑝𝑙𝑎𝑡𝑒 < 𝑐𝑙𝑎𝑠𝑠 𝑇 > 𝑣𝑜𝑖𝑑 𝑓 𝑇 𝑎𝑟𝑔 …  f(&x), f(&y) T2, T2 ?
30

MyT x;
const MyT& y = x;
𝑡𝑒𝑚𝑝𝑙𝑎𝑡𝑒 < 𝑐𝑙𝑎𝑠𝑠 𝑇 > 𝑣𝑜𝑖𝑑 𝑓 𝑇2 𝑎𝑟𝑔 …
— 𝑡𝑒𝑚𝑝𝑙𝑎𝑡𝑒 < 𝑐𝑙𝑎𝑠𝑠 𝑇 > 𝑣𝑜𝑖𝑑 𝑓 𝑇 𝑎𝑟𝑔 …  f(x), f(y) T2=MyT, T2=MyT
— 𝑡𝑒𝑚𝑝𝑙𝑎𝑡𝑒 < 𝑐𝑙𝑎𝑠𝑠 𝑇 > 𝑣𝑜𝑖𝑑 𝑓 𝑇& 𝑎𝑟𝑔 …  f(x), f(y) T2=MyT, T2=const MyT
— 𝑡𝑒𝑚𝑝𝑙𝑎𝑡𝑒 < 𝑐𝑙𝑎𝑠𝑠 𝑇 > 𝑣𝑜𝑖𝑑 𝑓 𝑐𝑜𝑛𝑠𝑡 𝑇& 𝑎𝑟𝑔 …  f(x), f(y) T2=MyT, T2=MyT
— 𝑡𝑒𝑚𝑝𝑙𝑎𝑡𝑒 < 𝑐𝑙𝑎𝑠𝑠 𝑇 > 𝑣𝑜𝑖𝑑 𝑓 𝑇&& 𝑎𝑟𝑔 …  f(x) T2=MyT&, T2=const MyT&
— 𝑡𝑒𝑚𝑝𝑙𝑎𝑡𝑒 < 𝑐𝑙𝑎𝑠𝑠 𝑇 > 𝑣𝑜𝑖𝑑 𝑓 𝑇 𝑎𝑟𝑔 …  f(&x), f(&y) T2=MyT*, T2=const MyT*
31

template <class T>
void f(const T& arg)
{ T par = arg; par.non_const_fn(); }
template <class T>
void f(T& arg)
template <class T>
void f(T arg)
32

 auto
33
struct S
{
S(int x) :m(x){}
int m;
};
S operator””_ma13
(unsigned long long x)
{
return S(static_cast<int>(x));
}
auto x1 = 13_ma13;
auto x2(13_ma13);
auto x3 = {13_ma13};
auto x4 {13_ma13};
auto x5 = {13_ma13, 13_ma13};
auto x6 {13_ma13, 13_ma13};
auto x7 ={13_ma13, 13};
template <class T>
void f(T);
f({13_ma13});
f({13_ma13, 13_ma13});
?
?
?
?
?
?
?
?
?

 auto
34
auto x1 = 13_ma13;
auto x2(13_ma13);
auto x3 = {13_ma13};
auto x4 {13_ma13};
auto x5 = {13_ma13, 13_ma13};
auto x6 {13_ma13, 13_ma13};
auto x7 ={13_ma13, 13};
template <class T>
void f(T);
f(13_ma13);
f({13_ma13});
f({13_ma13, 13_ma13});
S
S
std::initializer_list<S>
S
error …. (add ‘=‘ before the {)
S
error – cannot deduce T
error – cannot deduce T

 auto
35
auto f()
{ return 13_ma13;}
auto fn1 = [] (auto s) {…}
auto fn2 = [] (const auto& s)
{…}
f1(13_ma13);
f1({13_ma13});
f2({13_ma13});
?
cannot
?

 auto
36
auto f()
{ return 13_ma13;}
auto fn1 = [] (auto s) {…}
auto fn2 = [] (const auto& s)
{…}
f1(13_ma13);
f1({13_ma13});
f2({13_ma13});
S
a braced-enclosed list does not provide return value
a braced-enclosed list does not provide return value

 auto
• In general it’s the same as template type deduction. The main
difference is that auto assumes that a braced initializers
represents a std::initializer_list, but TTD-doesn’t.
• Auto in function return type or a lambda parameter implies TTD,
not auto type deduction.
37

 auto and decltype
38
int x[10];
auto f1(int i)
{ return x[i];}
decltype(auto) f2(int i)
{ return x[i];}
f1(0) = 4;
f2(0) = 4

 decltype
• Decltype almost always yields the type of expression without modification.
• For lvalues’ of type T decltype always reports a T&
39

 decltype
40
decltype(auto) f()
{
bool b;
…
return (b);
}
UNDEFINED BEHAVIOR!!!!!

 partial specialization
 static_assert
41
template <class T>
void g(T) {cout<<“A”;}
template <>
void g<int>(int){cout<<“B”;}
template <class T>
void f(T) { static_assert(std::is_same_v<T, int>); }
g(1); // B
g(1.); // A
f(1); // fine
f(1.); //compile error

 std::enable_if
42
template<class T, typename = void>
class A{};
template<class T>
class A<T, typename =
std::enable_if_t<std::is_fundamental_v<T>>
{};
template<class T, typename = void>
class A{};
template<class T>
std::enable_if_t<std::is_fundamental_v<T>>
{};
template<class T>
std::enable_if_t<std::is_integral_v<T>>
{};

class D
{virtual void f(){}};
template<class T>
class D
{
virtual void f(){};
};
template<class T>
class D
{
template <class T2=T>
virtual void f(){};
};
43
?
?
?

class D
{virtual void f(){}};
template<class T>
class D
{
virtual void f(){};
};
template<class T>
class D
{
template <class T2=T>
virtual void f(){};
};
44
OK
OK
Error – virtual is not allowed
in a function template
declaration

R-value references, Universal references, Move
semantics, Perfect Forwarding
 R-value references - &&
 Universal references - &&
 Move semantics - via std::move
 Perfect forwarding – via std::forward
45

 R-value references
46
void f(S&& obj)
{/…/}
f(13_ma13);
S x = 13_ma13;
f(x);
fine
an rvalue ref. cant be bound to an lvalue

 R-value references
47
struct S
{
void f1() & {}
void f2() && {}
};
auto x = 13_ma13;
x.f1();
x.f2();
fine
error- function can’t be called on lvalue

 Universal referances
48
template <class T>
void f(T&&)
{…}
auto&& s = 13_ma13;
If a function template parameter has type T&& for a deduced
type, or an object is declared using auto&&, the paramet or
object is a UR.
UR correspond to rvalue if they are initialized with rvalues. The
same for lvalue.

 Move semantics
49
std::vector<int> x{1,2,3,4};
std::vector<int> y=std::move(x);
assert(x.empty());
assert(y.size() == 4);
//possible impl.
template<typename T>
constexpr typename
std::remove_reference<T>::type&&
move(T&& t) noexcept
{
return static_cast<typename
std::remove_reference<T>::type&&>(t);
}

 Perfect Forwarding
50
template <class T>
void f1(T&& val)
{
f(val);
}
template <class T>
void f2(T&& val)
{
f(std::forward<T>(val));
}
S s = 13_ma13;
f1(s); //in f is passed ?
f1(13_ma13); // in f is passed ?
f2(s); // in f is passed ?
f2(13_ma13); // in f is passed ?

 Perfect Forwarding
51
void f(S&) {cout<<“lvalue”;}
void f(S&&) {cout<<“rvalue”;}
template <class T>
void f1(T&& val)
{
f(val);
}
template <class T>
void f2(T&& val)
{
f(std::forward<T>(val));
}
S s = 13_ma13;
f1(s); //lvalue
f1(13_ma13); // lvalue
f2(s); // lvalue
f2(13_ma13); // rvalue

 Use std::move on rvalue referances, std::forward on universal
referances.
 Never use std::move or std::forward to local objects it they would
otherwise be eligible for the RVO.
52

 Variadic templates
53
template<typename … Args>
void f(Args&& …args)
{
f1(std::forward<Args>(args)…);
}
template<typename … Args>
class A
{
public:
void f(Args&&… args)
{
f1(std::forward<Args>(args)…);
}
};

template <class T>
struct A
{
void f(T&& obj)
{}
template <class T2 = T>
void f2(T2&& obj)
{}
};
54
A<S> obj;
S obj = 13_ma13;
obj.f(13_ma13);
obj.f(s);
obj.f2(13_ma13);
obj.f2(s);
?
?
?
?

template <class T>
struct A
{
void f(T&& obj)
{}
template <class T2 = T>
void f2(T2&& obj)
{}
};
55
A<S> obj;
S obj = 13_ma13;
obj.f(13_ma13);
obj.f(s);
obj.f2(13_ma13);
obj.f2(s);
OK
error
OK
OK

Smart pointers, STL
 Smart pointers
• unique_ptr
• shared_ptr
• weak_ptr
56

Smart pointers, STL
 Smart pointers – unique_ptr
• Movable, non-copyable
57
template <typename T, typename D>
class unique_ptr;
template<typename T, typename D>
class unique_ptr<T[], D>;
template <typename T, typeneme … Args>
unique_ptr make_unique(Args&&… args);

Smart pointers, STL
 Smart pointers – shared_ptr
• Movable, copyable
58
template <typename T>
class shared_ptr;
template<class T, typename … Args>
shared_ptr<T> make_shared(Args&& … args);

Smart pointers, STL
 Smart pointers – weak_ptr
• Movable, copyable
59
template<class T>
class weak_ptr
{
…
shared_ptr<T> lock();
…
};

Smart pointers, STL
 STL
• std::array
• std::unordered_set/map
• std::unordered_multiset/multimap
• std::emplace for all containers
• Parallel execution support for STL algorithms
60

Concurrency – multitasking, multithreading
 multi-threading
 multi-tasking
 std::mutex
 std::condition_variable
 std::atomic
 std::thread
 std::future
 std::async
61

62
Thank you!

Core concepts of C++

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Core concepts of C++

Similar to Core concepts of C++ (20)

Recently uploaded

Recently uploaded (20)

Core concepts of C++