Pointless Pointers - How to make our interfaces efficient?

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

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

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
WHAT IS A POINTER?
2

WHAT IS A POINTER?
3

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 ☺
WHAT IS A POINTER?
3

POINTERS MISUSE LEADS TO
4

Null Pointer Dereference
4

Resource leaks
4

Resource leaks
Bu er Overflows
4

Resource leaks
Bu er Overflows
Hangs!
4

Resource leaks
Bu er Overflows
Hangs!
Crashes!
4

Resource leaks
Bu er Overflows
Hangs!
Crashes!Stability!!!
4

Resource leaks
Bu er Overflows
Hangs!
Crashes!Stability!!!
Security!!!
4

B* a(A* ptr) { /* ... */; return b(ptr); }
PROBLEM DEFINITION
5

B* b(A* ptr) { /* ... */; return c(ptr); }
PROBLEM DEFINITION
5

B* c(A* ptr) { /* ... */; return d(ptr); }
PROBLEM DEFINITION
5

B* d(A* ptr) { /* ... */; return e(ptr); }
PROBLEM DEFINITION
5

B* e(A* ptr) { /* ... */; return f(ptr); }
PROBLEM DEFINITION
5

B* f(A* ptr) { /* ... */; return g(ptr); }
PROBLEM DEFINITION
5

B* f(A* ptr) { /* ... */; return g(ptr); }
B* g(A* ptr) { /* ... */; return *ptr; }
PROBLEM DEFINITION
5

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; }
PROBLEM DEFINITION
6

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; }
PROBLEM DEFINITION
7

B* func(A* arg);
QUIZ - GUESS WHAT?
8

person* add(name* n);
QUIZ - GUESS WHAT?
9

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

void foo()
{
person* p = add(new name{"Mateusz Pusz"});
assert(p != nullptr);
process(p->id(), p->name());
delete p;
}
ADD() USAGE – TAKE #1
10

void foo()
{
delete p;
}
Is that a valid usage of add() interface?
What are potential problems with above code?
10

void foo()
{
name n{"Mateusz Pusz"};
person* p = add(&n);
if(p != nullptr)
}
11

void foo()
{
if(p != nullptr)
}
11

void foo()
{
name* n = new name{"Mateusz Pusz"};
person* p = add(n);
if(p != nullptr)
delete n;
}
12

void foo()
{
person* p = add(n);
if(p != nullptr)
delete n;
}
12

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;
}
13

void foo()
{
delete[] people;
}
13

void foo()
{
delete p;
}
void foo()
{
if(p != nullptr)
}
void foo()
{
person* p = add(n);
if(p != nullptr)
delete n;
}
void foo()
{
delete[] people;
}
1
2
3
4
WHICH ONE IS CORRECT?
14

void foo()
{
delete p;
}
void foo()
{
if(p != nullptr)
}
void foo()
{
person* p = add(n);
if(p != nullptr)
delete n;
}
void foo()
{
delete[] people;
}
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

void foo()
{
delete p;
}
void foo()
{
person* p = add(n);
if(p != nullptr)
delete n;
}
void foo()
{
delete[] people;
}
1
void foo()
{
if(p != nullptr)
}
2
3
4
{
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

void foo()
{
delete p;
}
void foo()
{
person* p = add(n);
if(p != nullptr)
delete n;
}
1
void foo()
{
if(p != nullptr)
}
2
3
void foo()
{
delete[] people;
}
4
{
assert(n != nullptr);
return new person{n};
}
17

void foo()
{
person* p = add(n);
if(p != nullptr)
delete n;
}
void foo()
{
delete p;
}
void foo()
{
if(p != nullptr)
}
1
2
3
void foo()
{
delete[] people;
}
4
{
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);
}
18

void foo()
{
delete p;
}
void foo()
{
if(p != nullptr)
}
void foo()
{
person* p = add(n);
if(p != nullptr)
delete n;
}
void foo()
{
delete[] people;
}
1
2
3
4
19

person*
add(name* n);
IS THERE A BETTER SOLUTION?
20

person*
add(name* n);
std::unique_ptr<person>
add(std::unique_ptr<name> n);
20

person*
add(name* n);
add(std::unique_ptr<name> n);
20

person*
add(name* n)
{
}
void foo()
{
person* p = add(
new name{"Mateusz Pusz"});
delete p;
}
USING C++ THE RIGHT WAY – CASE #1
21

void foo()
{
auto p = add(
std::make_unique<name>("Mateusz Pusz"));
}
add(std::unique_ptr<name> n)
{
return std::make_unique<person>(std::move(n));
}
person*
add(name* n)
{
}
void foo()
{
person* p = add(
new name{"Mateusz Pusz"});
delete p;
}
21

person*
add(name* n);
22

person*
add(name* n);
person&
add(std::optional<name> n);
22

{
people.emplace_back(
(n != nullptr) ? *n : "anonymous");
}
void foo()
{
if(p != nullptr)
}
23

person& add(std::optional<name> n)
{
n ? std::move(*n) : "anonymous");
return people.back();
}
void foo()
{
person& p = add(name{"Mateusz Pusz"});
process(p.id(), p.name());
}
{
(n != nullptr) ? *n : "anonymous");
}
void foo()
{
if(p != nullptr)
}
23

person*
add(name* n);
24

person*
add(name* n);
std::tuple<person&, bool>
add(name n);
24

{
if(n == nullptr) return nullptr;
auto it = find_if(
begin(people), end(people),
[&](person& p) { return p.name() == *n; });
return nullptr;
}
void foo()
{
person* p = add(n);
if(p != nullptr)
delete n;
}
25

std::tuple<person&, bool> add(name n)
{
auto it = find_if(
[&](person& p) { return p.name() == n; });
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());
}
{
if(n == nullptr) return nullptr;
auto it = find_if(
[&](person& p) { return p.name() == *n; });
return nullptr;
}
void foo()
{
person* p = add(n);
if(p != nullptr)
delete n;
}
25

person*
add(name* n);
26

person*
add(name* n);
std::vector<person>
add(std::vector<name> names);
26

{
assert(n);
int num = 0;
++num;
p[i].name(n[i]);
return p;
}
void foo()
{
delete[] people;
}
27

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());
}
{
assert(n);
int num = 0;
++num;
p[i].name(n[i]);
return p;
}
void foo()
{
delete[] people;
}
27

Pointless Pointers - How to make our interfaces efficient?

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);
POINTERS USAGE IN ANSI C
29

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);
POINTERS USAGE IN ANSI C
Pointer ambiguity makes it really hard to understand the intent of the
interface author.
29

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);
DOING IT C++ WAY
30

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);
DOING IT C++ WAY
Use above Modern C++ constructs to explicitly state your design intent.
30

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);
QUIZ – GUESS WHAT?
31

int count_lower(const char* ptr, size_t size);
void add_2(int* ptr, size_t size);
C++17 AND C++20: WHAT ABOUT POINTER AND A SIZE
ANSI C -> C++14
ANSI C -> C++14
32

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);
C++17 AND C++20: WHAT ABOUT POINTER AND A SIZE
ANSI C -> C++14
ANSI C -> C++14
C++17
C++20
32

C++ is a powerful tool:
• strong type system
• better abstractions
• templates
• C++ STD library
C++ IS NOT ANSI C!!!
34

Pointless Pointers - How to make our interfaces efficient?

More Related Content

What's hot (19)

Similar to Pointless Pointers - How to make our interfaces efficient? (20)

More from Mateusz Pusz (15)

Recently uploaded (20)

Pointless Pointers - How to make our interfaces efficient?