These are the slides from my code::dive 2017 talk. You can find the recording here: https://www.youtube.com/watch?v=qrifyjQW9gA. All my other talks can be found here: https://train-it.eu/resources. --- C++ is not C. C++ developers too often forget about that. The effects are often disastrous. nullptr dereferences, buffer overflows, resource leaks are the problems often seen in C++ applications bug trackers. Does it have to be like that? The talk presents a few simple rules tested in production that will make most of those issues go away and never appear again in the C++ software. Interested? Come and see :-)

1. Mateusz Pusz
November 15, 2017
POINTLESS POINTERS
HOW TO MAKE OUR INTERFACES EFFICIENT?

2. code::dive 2017 | Pointless Pointers
WHAT IS A POINTER?
2

3. A pointer is a programming language data type whose value refers
directly to (or "points to") another value stored elsewhere in the
computer memory using its address.
-- Wikipedia
code::dive 2017 | Pointless Pointers
WHAT IS A POINTER?
2

4. code::dive 2017 | Pointless Pointers
WHAT IS A POINTER?
3

5. Pointers due to their ambiguous nature are the source of most
problems and bugs in C++ code. Lack of understanding between
code architect and the user results in crashes, asserts and memory
leaks!!!
-- Mateusz Pusz ☺
code::dive 2017 | Pointless Pointers
WHAT IS A POINTER?
3

6. code::dive 2017 | Pointless Pointers
POINTERS MISUSE LEADS TO
4

7. code::dive 2017 | Pointless Pointers
POINTERS MISUSE LEADS TO
Null Pointer Dereference
4

8. code::dive 2017 | Pointless Pointers
POINTERS MISUSE LEADS TO
Null Pointer Dereference
Resource leaks
4

9. code::dive 2017 | Pointless Pointers
POINTERS MISUSE LEADS TO
Null Pointer Dereference
Resource leaks
Bu er Overflows
4

10. code::dive 2017 | Pointless Pointers
POINTERS MISUSE LEADS TO
Null Pointer Dereference
Resource leaks
Bu er Overflows
Hangs!
4

11. code::dive 2017 | Pointless Pointers
POINTERS MISUSE LEADS TO
Null Pointer Dereference
Resource leaks
Bu er Overflows
Hangs!
Crashes!
4

12. code::dive 2017 | Pointless Pointers
POINTERS MISUSE LEADS TO
Null Pointer Dereference
Resource leaks
Bu er Overflows
Hangs!
Crashes!Stability!!!
4

13. code::dive 2017 | Pointless Pointers
POINTERS MISUSE LEADS TO
Null Pointer Dereference
Resource leaks
Bu er Overflows
Hangs!
Crashes!Stability!!!
Security!!!
4

14. B* a(A* ptr) { /* ... */; return b(ptr); }
code::dive 2017 | Pointless Pointers
PROBLEM DEFINITION
5

15. B* a(A* ptr) { /* ... */; return b(ptr); }
B* b(A* ptr) { /* ... */; return c(ptr); }
code::dive 2017 | Pointless Pointers
PROBLEM DEFINITION
5

16. B* a(A* ptr) { /* ... */; return b(ptr); }
B* b(A* ptr) { /* ... */; return c(ptr); }
B* c(A* ptr) { /* ... */; return d(ptr); }
code::dive 2017 | Pointless Pointers
PROBLEM DEFINITION
5

17. B* a(A* ptr) { /* ... */; return b(ptr); }
B* b(A* ptr) { /* ... */; return c(ptr); }
B* c(A* ptr) { /* ... */; return d(ptr); }
B* d(A* ptr) { /* ... */; return e(ptr); }
code::dive 2017 | Pointless Pointers
PROBLEM DEFINITION
5

18. B* a(A* ptr) { /* ... */; return b(ptr); }
B* b(A* ptr) { /* ... */; return c(ptr); }
B* c(A* ptr) { /* ... */; return d(ptr); }
B* d(A* ptr) { /* ... */; return e(ptr); }
B* e(A* ptr) { /* ... */; return f(ptr); }
code::dive 2017 | Pointless Pointers
PROBLEM DEFINITION
5

19. B* a(A* ptr) { /* ... */; return b(ptr); }
B* b(A* ptr) { /* ... */; return c(ptr); }
B* c(A* ptr) { /* ... */; return d(ptr); }
B* d(A* ptr) { /* ... */; return e(ptr); }
B* e(A* ptr) { /* ... */; return f(ptr); }
B* f(A* ptr) { /* ... */; return g(ptr); }
code::dive 2017 | Pointless Pointers
PROBLEM DEFINITION
5

20. B* a(A* ptr) { /* ... */; return b(ptr); }
B* b(A* ptr) { /* ... */; return c(ptr); }
B* c(A* ptr) { /* ... */; return d(ptr); }
B* d(A* ptr) { /* ... */; return e(ptr); }
B* e(A* ptr) { /* ... */; return f(ptr); }
B* f(A* ptr) { /* ... */; return g(ptr); }
B* g(A* ptr) { /* ... */; return *ptr; }
code::dive 2017 | Pointless Pointers
PROBLEM DEFINITION
5

21. B* a(A* ptr) { /* ... */; assert(ptr); return b(ptr); }
B* b(A* ptr) { /* ... */; assert(ptr); return c(ptr); }
B* c(A* ptr) { /* ... */; assert(ptr); return d(ptr); }
B* d(A* ptr) { /* ... */; assert(ptr); return e(ptr); }
B* e(A* ptr) { /* ... */; assert(ptr); return f(ptr); }
B* f(A* ptr) { /* ... */; assert(ptr); return g(ptr); }
B* g(A* ptr) { /* ... */; assert(ptr); return *ptr; }
code::dive 2017 | Pointless Pointers
PROBLEM DEFINITION
6

22. B* a(A* ptr) { /* ... */; if(!ptr) throw std::invalid_argument{""}; return b(ptr); }
B* b(A* ptr) { /* ... */; if(!ptr) throw std::invalid_argument{""}; return c(ptr); }
B* c(A* ptr) { /* ... */; if(!ptr) throw std::invalid_argument{""}; return d(ptr); }
B* d(A* ptr) { /* ... */; if(!ptr) throw std::invalid_argument{""}; return e(ptr); }
B* e(A* ptr) { /* ... */; if(!ptr) throw std::invalid_argument{""}; return f(ptr); }
B* f(A* ptr) { /* ... */; if(!ptr) throw std::invalid_argument{""}; return g(ptr); }
B* g(A* ptr) { /* ... */; if(!ptr) throw std::invalid_argument{""}; return *ptr; }
code::dive 2017 | Pointless Pointers
PROBLEM DEFINITION
7

23. B* func(A* arg);
code::dive 2017 | Pointless Pointers
QUIZ - GUESS WHAT?
8

24. person* add(name* n);
code::dive 2017 | Pointless Pointers
QUIZ - GUESS WHAT?
9

25. person* add(name* n);
code::dive 2017 | Pointless Pointers
QUIZ - GUESS WHAT?
Is it better now?
Is it enough?
Do you know how to use that function?
Do you know how to implement that function?
9

26. person* add(name* n);
void foo()
{
person* p = add(new name{"Mateusz Pusz"});
assert(p != nullptr);
process(p->id(), p->name());
delete p;
}
code::dive 2017 | Pointless Pointers
ADD() USAGE – TAKE #1
10

27. person* add(name* n);
void foo()
{
person* p = add(new name{"Mateusz Pusz"});
assert(p != nullptr);
process(p->id(), p->name());
delete p;
}
code::dive 2017 | Pointless Pointers
ADD() USAGE – TAKE #1
Is that a valid usage of add() interface?
What are potential problems with above code?
10

28. person* add(name* n);
void foo()
{
name n{"Mateusz Pusz"};
person* p = add(&n);
if(p != nullptr)
process(p->id(), p->name());
}
code::dive 2017 | Pointless Pointers
ADD() USAGE – TAKE #2
11

29. person* add(name* n);
void foo()
{
name n{"Mateusz Pusz"};
person* p = add(&n);
if(p != nullptr)
process(p->id(), p->name());
}
code::dive 2017 | Pointless Pointers
ADD() USAGE – TAKE #2
Is that a valid usage of add() interface?
11

30. person* add(name* n);
void foo()
{
name* n = new name{"Mateusz Pusz"};
person* p = add(n);
if(p != nullptr)
process(p->id(), p->name());
delete n;
}
code::dive 2017 | Pointless Pointers
ADD() USAGE – TAKE #3
12

31. person* add(name* n);
void foo()
{
name* n = new name{"Mateusz Pusz"};
person* p = add(n);
if(p != nullptr)
process(p->id(), p->name());
delete n;
}
code::dive 2017 | Pointless Pointers
ADD() USAGE – TAKE #3
Is that a valid usage of add() interface?
What are potential problems with above code?
12

32. person* add(name* n);
void foo()
{
name names[] = {"Mateusz Pusz", "Jan Kowalski", ""};
person* people = add(names);
assert(people != nullptr);
for(int i=0; i<sizeof(names)/sizeof(*names) - 1; ++i)
process(people[i].id(), people[i].name());
delete[] people;
}
code::dive 2017 | Pointless Pointers
ADD() USAGE – TAKE #4
13

33. person* add(name* n);
void foo()
{
name names[] = {"Mateusz Pusz", "Jan Kowalski", ""};
person* people = add(names);
assert(people != nullptr);
for(int i=0; i<sizeof(names)/sizeof(*names) - 1; ++i)
process(people[i].id(), people[i].name());
delete[] people;
}
code::dive 2017 | Pointless Pointers
ADD() USAGE – TAKE #4
Is that a valid usage of add() interface?
What are potential problems with above code?
13

34. void foo()
{
person* p = add(new name{"Mateusz Pusz"});
assert(p != nullptr);
process(p->id(), p->name());
delete p;
}
void foo()
{
name n{"Mateusz Pusz"};
person* p = add(&n);
if(p != nullptr)
process(p->id(), p->name());
}
void foo()
{
name* n = new name{"Mateusz Pusz"};
person* p = add(n);
if(p != nullptr)
process(p->id(), p->name());
delete n;
}
void foo()
{
name names[] = {"Mateusz Pusz", "Jan Kowalski", ""};
person* people = add(names);
assert(people != nullptr);
for(int i=0; i<sizeof(names)/sizeof(*names) - 1; ++i)
process(people[i].id(), people[i].name());
delete[] people;
}
code::dive 2017 | Pointless Pointers
1
2
3
4
WHICH ONE IS CORRECT?
14

35. void foo()
{
person* p = add(new name{"Mateusz Pusz"});
assert(p != nullptr);
process(p->id(), p->name());
delete p;
}
void foo()
{
name n{"Mateusz Pusz"};
person* p = add(&n);
if(p != nullptr)
process(p->id(), p->name());
}
void foo()
{
name* n = new name{"Mateusz Pusz"};
person* p = add(n);
if(p != nullptr)
process(p->id(), p->name());
delete n;
}
void foo()
{
name names[] = {"Mateusz Pusz", "Jan Kowalski", ""};
person* people = add(names);
assert(people != nullptr);
for(int i=0; i<sizeof(names)/sizeof(*names) - 1; ++i)
process(people[i].id(), people[i].name());
delete[] people;
}
code::dive 2017 | Pointless Pointers
1
2
3
4
QUIZ - MATCH IMPLEMENTATION
std::deque<person> people;
person* add(name* n)
{
people.emplace_back((n != nullptr) ? *n : "anonymous");
return &people.back();
}
15

36. void foo()
{
person* p = add(new name{"Mateusz Pusz"});
assert(p != nullptr);
process(p->id(), p->name());
delete p;
}
void foo()
{
name* n = new name{"Mateusz Pusz"};
person* p = add(n);
if(p != nullptr)
process(p->id(), p->name());
delete n;
}
void foo()
{
name names[] = {"Mateusz Pusz", "Jan Kowalski", ""};
person* people = add(names);
assert(people != nullptr);
for(int i=0; i<sizeof(names)/sizeof(*names) - 1; ++i)
process(people[i].id(), people[i].name());
delete[] people;
}
code::dive 2017 | Pointless Pointers
QUIZ - MATCH IMPLEMENTATION
1
void foo()
{
name n{"Mateusz Pusz"};
person* p = add(&n);
if(p != nullptr)
process(p->id(), p->name());
}
2
3
4
person* add(name* n)
{
assert(n);
int num = 0;
for(auto ptr = n; *ptr != ""; ++ptr)
++num;
person* p = new person[num];
for(auto i = 0; i<num; ++i)
p[i].name(n[i]);
return p;
}
16

37. void foo()
{
person* p = add(new name{"Mateusz Pusz"});
assert(p != nullptr);
process(p->id(), p->name());
delete p;
}
void foo()
{
name* n = new name{"Mateusz Pusz"};
person* p = add(n);
if(p != nullptr)
process(p->id(), p->name());
delete n;
}
code::dive 2017 | Pointless Pointers
QUIZ - MATCH IMPLEMENTATION
1
void foo()
{
name n{"Mateusz Pusz"};
person* p = add(&n);
if(p != nullptr)
process(p->id(), p->name());
}
2
3
void foo()
{
name names[] = {"Mateusz Pusz", "Jan Kowalski", ""};
person* people = add(names);
assert(people != nullptr);
for(int i=0; i<sizeof(names)/sizeof(*names) - 1; ++i)
process(people[i].id(), people[i].name());
delete[] people;
}
4
person* add(name* n)
{
assert(n != nullptr);
return new person{n};
}
17

38. void foo()
{
name* n = new name{"Mateusz Pusz"};
person* p = add(n);
if(p != nullptr)
process(p->id(), p->name());
delete n;
}
code::dive 2017 | Pointless Pointers
QUIZ - MATCH IMPLEMENTATION
void foo()
{
person* p = add(new name{"Mateusz Pusz"});
assert(p != nullptr);
process(p->id(), p->name());
delete p;
}
void foo()
{
name n{"Mateusz Pusz"};
person* p = add(&n);
if(p != nullptr)
process(p->id(), p->name());
}
1
2
3
void foo()
{
name names[] = {"Mateusz Pusz", "Jan Kowalski", ""};
person* people = add(names);
assert(people != nullptr);
for(int i=0; i<sizeof(names)/sizeof(*names) - 1; ++i)
process(people[i].id(), people[i].name());
delete[] people;
}
4
std::deque<person> people;
person* add(name* n)
{
if(n == nullptr)
return nullptr;
auto it = find_if(begin(people), end(people),
[&](person& p)
{ return p.name() == *n; });
if(it != end(people))
return nullptr;
people.emplace_back(*n);
return &people.back();
}
18

39. code::dive 2017 | Pointless Pointers
QUIZ - MATCH IMPLEMENTATION
void foo()
{
person* p = add(new name{"Mateusz Pusz"});
assert(p != nullptr);
process(p->id(), p->name());
delete p;
}
void foo()
{
name n{"Mateusz Pusz"};
person* p = add(&n);
if(p != nullptr)
process(p->id(), p->name());
}
void foo()
{
name* n = new name{"Mateusz Pusz"};
person* p = add(n);
if(p != nullptr)
process(p->id(), p->name());
delete n;
}
void foo()
{
name names[] = {"Mateusz Pusz", "Jan Kowalski", ""};
person* people = add(names);
assert(people != nullptr);
for(int i=0; i<sizeof(names)/sizeof(*names) - 1; ++i)
process(people[i].id(), people[i].name());
delete[] people;
}
1
2
3
4
19

40. person*
add(name* n);
code::dive 2017 | Pointless Pointers
IS THERE A BETTER SOLUTION?
20

41. person*
add(name* n);
std::unique_ptr<person>
add(std::unique_ptr<name> n);
code::dive 2017 | Pointless Pointers
IS THERE A BETTER SOLUTION?
20

42. person*
add(name* n);
std::unique_ptr<person>
add(std::unique_ptr<name> n);
code::dive 2017 | Pointless Pointers
IS THERE A BETTER SOLUTION?
Do you know how to use that function?
Do you know how to implement that function?
20

43. person*
add(name* n)
{
assert(n != nullptr);
return new person{n};
}
void foo()
{
person* p = add(
new name{"Mateusz Pusz"});
assert(p != nullptr);
process(p->id(), p->name());
delete p;
}
code::dive 2017 | Pointless Pointers
USING C++ THE RIGHT WAY – CASE #1
21

44. void foo()
{
auto p = add(
std::make_unique<name>("Mateusz Pusz"));
assert(p != nullptr);
process(p->id(), p->name());
}
std::unique_ptr<person>
add(std::unique_ptr<name> n)
{
assert(n != nullptr);
return std::make_unique<person>(std::move(n));
}
code::dive 2017 | Pointless Pointers
USING C++ THE RIGHT WAY – CASE #1
person*
add(name* n)
{
assert(n != nullptr);
return new person{n};
}
void foo()
{
person* p = add(
new name{"Mateusz Pusz"});
assert(p != nullptr);
process(p->id(), p->name());
delete p;
}
21

45. person*
add(name* n);
code::dive 2017 | Pointless Pointers
IS THERE A BETTER SOLUTION?
22

46. person*
add(name* n);
person&
add(std::optional<name> n);
code::dive 2017 | Pointless Pointers
IS THERE A BETTER SOLUTION?
22

47. person*
add(name* n);
person&
add(std::optional<name> n);
code::dive 2017 | Pointless Pointers
IS THERE A BETTER SOLUTION?
Do you know how to use that function?
Do you know how to implement that function?
22

48. std::deque<person> people;
person* add(name* n)
{
people.emplace_back(
(n != nullptr) ? *n : "anonymous");
return &people.back();
}
void foo()
{
name n{"Mateusz Pusz"};
person* p = add(&n);
if(p != nullptr)
process(p->id(), p->name());
}
code::dive 2017 | Pointless Pointers
USING C++ THE RIGHT WAY – CASE #2
23

49. std::deque<person> people;
person& add(std::optional<name> n)
{
people.emplace_back(
n ? std::move(*n) : "anonymous");
return people.back();
}
void foo()
{
person& p = add(name{"Mateusz Pusz"});
process(p.id(), p.name());
}
code::dive 2017 | Pointless Pointers
USING C++ THE RIGHT WAY – CASE #2
std::deque<person> people;
person* add(name* n)
{
people.emplace_back(
(n != nullptr) ? *n : "anonymous");
return &people.back();
}
void foo()
{
name n{"Mateusz Pusz"};
person* p = add(&n);
if(p != nullptr)
process(p->id(), p->name());
}
23

50. person*
add(name* n);
code::dive 2017 | Pointless Pointers
IS THERE A BETTER SOLUTION?
24

51. person*
add(name* n);
std::tuple<person&, bool>
add(name n);
code::dive 2017 | Pointless Pointers
IS THERE A BETTER SOLUTION?
24

52. person*
add(name* n);
std::tuple<person&, bool>
add(name n);
code::dive 2017 | Pointless Pointers
IS THERE A BETTER SOLUTION?
Do you know how to use that function?
Do you know how to implement that function?
24

53. std::deque<person> people;
person* add(name* n)
{
if(n == nullptr) return nullptr;
auto it = find_if(
begin(people), end(people),
[&](person& p) { return p.name() == *n; });
if(it != end(people))
return nullptr;
people.emplace_back(*n);
return &people.back();
}
void foo()
{
name* n = new name{"Mateusz Pusz"};
person* p = add(n);
if(p != nullptr)
process(p->id(), p->name());
delete n;
}
code::dive 2017 | Pointless Pointers
USING C++ THE RIGHT WAY – CASE #3
25

54. std::deque<person> people;
std::tuple<person&, bool> add(name n)
{
auto it = find_if(
begin(people), end(people),
[&](person& p) { return p.name() == n; });
if(it != end(people))
return { *it, false };
people.emplace_back(std::move(n));
return { people.back(), true };
}
void foo()
{
auto r = add(name{"Mateusz Pusz"});
if(std::get<bool>(r))
process(std::get<0>(r).id(), std::get<0>(r).name());
}
code::dive 2017 | Pointless Pointers
USING C++ THE RIGHT WAY – CASE #3
std::deque<person> people;
person* add(name* n)
{
if(n == nullptr) return nullptr;
auto it = find_if(
begin(people), end(people),
[&](person& p) { return p.name() == *n; });
if(it != end(people))
return nullptr;
people.emplace_back(*n);
return &people.back();
}
void foo()
{
name* n = new name{"Mateusz Pusz"};
person* p = add(n);
if(p != nullptr)
process(p->id(), p->name());
delete n;
}
25

55. person*
add(name* n);
code::dive 2017 | Pointless Pointers
IS THERE A BETTER SOLUTION?
26

56. person*
add(name* n);
std::vector<person>
add(std::vector<name> names);
code::dive 2017 | Pointless Pointers
IS THERE A BETTER SOLUTION?
26

57. person*
add(name* n);
std::vector<person>
add(std::vector<name> names);
code::dive 2017 | Pointless Pointers
IS THERE A BETTER SOLUTION?
Do you know how to use that function?
Do you know how to implement that function?
26

58. person* add(name* n)
{
assert(n);
int num = 0;
for(auto ptr = n; *ptr != ""; ++ptr)
++num;
person* p = new person[num];
for(auto i = 0; i<num; ++i)
p[i].name(n[i]);
return p;
}
void foo()
{
name names[] = {"Mateusz Pusz", "Jan Kowalski", ""};
person* people = add(names);
assert(people != nullptr);
for(int i=0; i<sizeof(names)/sizeof(*names) - 1; ++i)
process(people[i].id(), people[i].name());
delete[] people;
}
code::dive 2017 | Pointless Pointers
USING C++ THE RIGHT WAY – CASE #4
27

59. std::vector<person> add(std::vector<name> names)
{
std::vector<person> p;
p.reserve(names.size());
for(auto& n : names)
p.emplace_back(std::move(n));
return p;
}
void foo()
{
auto people = add({"Mateusz Pusz", "Jan Kowalski"});
for(auto& p : people)
process(p.id(), p.name());
}
code::dive 2017 | Pointless Pointers
USING C++ THE RIGHT WAY – CASE #4
person* add(name* n)
{
assert(n);
int num = 0;
for(auto ptr = n; *ptr != ""; ++ptr)
++num;
person* p = new person[num];
for(auto i = 0; i<num; ++i)
p[i].name(n[i]);
return p;
}
void foo()
{
name names[] = {"Mateusz Pusz", "Jan Kowalski", ""};
person* people = add(names);
assert(people != nullptr);
for(int i=0; i<sizeof(names)/sizeof(*names) - 1; ++i)
process(people[i].id(), people[i].name());
delete[] people;
}
27

61. ARGUMENT TYPE POINTER ARGUMENT DECLARATION
Mandatory big value void foo(A* in);
Output function argument void foo(A* out);
Array void foo(A* array);
Optional value void foo(A* opt);
Ownership passing void foo(A* ptr);
code::dive 2017 | Pointless Pointers
POINTERS USAGE IN ANSI C
29

62. ARGUMENT TYPE POINTER ARGUMENT DECLARATION
Mandatory big value void foo(A* in);
Output function argument void foo(A* out);
Array void foo(A* array);
Optional value void foo(A* opt);
Ownership passing void foo(A* ptr);
code::dive 2017 | Pointless Pointers
POINTERS USAGE IN ANSI C
Pointer ambiguity makes it really hard to understand the intent of the
interface author.
29

63. ARGUMENT TYPE POINTER ARGUMENT DECLARATION
Mandatory big value void foo(const A& in);
Output function argument A foo(); or std::tuple<...> foo(); or void foo(A& out);
Array void foo(const std::vector<A>& a);
Optional value void foo(std::optional<A> opt); or void foo(A* opt);
Ownership passing void foo(std::unique_ptr<A> ptr);
code::dive 2017 | Pointless Pointers
DOING IT C++ WAY
30

64. ARGUMENT TYPE POINTER ARGUMENT DECLARATION
Mandatory big value void foo(const A& in);
Output function argument A foo(); or std::tuple<...> foo(); or void foo(A& out);
Array void foo(const std::vector<A>& a);
Optional value void foo(std::optional<A> opt); or void foo(A* opt);
Ownership passing void foo(std::unique_ptr<A> ptr);
code::dive 2017 | Pointless Pointers
DOING IT C++ WAY
Use above Modern C++ constructs to explicitly state your design intent.
30

65. B foo(std::optional<A> arg);
const A& foo(const std::array<A, 3>& arg);
std::unique_ptr<B> foo(A arg);
std::vector<B> foo(const A& arg);
code::dive 2017 | Pointless Pointers
QUIZ – GUESS WHAT?
31

66. int count_lower(const char* ptr, size_t size);
void add_2(int* ptr, size_t size);
code::dive 2017 | Pointless Pointers
C++17 AND C++20: WHAT ABOUT POINTER AND A SIZE
ANSI C -> C++14
ANSI C -> C++14
32

67. int count_lower(const char* ptr, size_t size);
void add_2(int* ptr, size_t size);
int count_lower(std::string_view txt);
void add_2(std::span<int> array);
code::dive 2017 | Pointless Pointers
C++17 AND C++20: WHAT ABOUT POINTER AND A SIZE
ANSI C -> C++14
ANSI C -> C++14
C++17
C++20
32

68. TAKEAWAYS

69. C++ is a powerful tool:
• strong type system
• better abstractions
• templates
• C++ STD library
code::dive 2017 | Pointless Pointers
C++ IS NOT ANSI C!!!
34