C++ Modern and Lucid C++ for Professional Programmers

Transcription

1 Informatik C++ Modern and Lucid C++ for Professional Programmers part 13 Prof. Peter Sommerlad Institutsleiter IFS Institute for Software Rapperswil, HS 2017

2 main(argc,argv) Arrays & Pointer passing arguments to C++ programs dealing with legacy data structures To be avoided!

3 Passing Program Arguments int main(int argc, char *argv[]) array of pointers to char representing strings As with many other languages you can pass command-line arguments to a C++ program Mechanism is inherited from C uses pointers and array argument require separate element counter (as all C arrays) char * represents a string in C char sequence terminated by '\0' 3

4 "Naked" Arrays as parameters int main(int argc, char *argv[]) Defining a function parameter as array means just passing a naked pointer to the first element array dimension is lost int main(int argc, char **argv) -> use std::array or vector in own code You either need to pass the dimension separately (argc) or have other means to know the sequence end (e.g., '\0' terminating a C string) or use a template function deducing the type soon: span/view(c++20) and string_view(c++17) 4

5 Pointers to Arrays are Random-access Iterators int main(int argc, char *argv[]){ copy(argv+1, argv+argc, std::ostream_iterator<std::string>{std::cout,"-"); Array parameters are naked pointers p = first element, p+dimension=past-the-end implementation of echo program they work like random access iterators ++p, *p, p+int, p[int], *(p+int) also int[p] syntactically possible -> confusion! 5

6 Initializing an Array int five[5]{; int four[4]={1,2,3,4; double d[4]{1.0, 2.0,; double m[2][3]{{1,2,3,{4,5,6; Arrays get a dimension = number of elements 5 zeros d[2]==d[3]==0.0 arrays without initializer might be uninitialized Missing initializer values -> default value multi-dimensional arrays are possible int x[5][6] -> x is array of 5 elements that are arrays of 6 elements of type int x[1,2] -> possible but wrong -> x[2]! (comma operator) 6 char s[6]{"hello"; 5 chars + '\0'

7 comma operator,()? what does that mean? double m[2][3]{{1,2,3,{4,5,6; m[0,1]; Caution: multi-dimensional index access requires all brackets to be present: m[0][1] using a comma is syntactically correct (comma operator): a, b, means sequential evaluation of sub-expressions usually only useful if first part has a side effect one can even overload operator,(a, b) which looses the sequential evaluation property 7

8 Deducing Array Dimensions template <typename T, unsigned N> void printarray(std::ostream &out, T const (&x)[n]){ copy(x, x+n, std::ostream_iterator<t>{out,", "); () are needed Passing an array type by reference in a template function allows dimension deduction by template argument deduction T (&x)[n] could just have N deduced if array element type is fixed Initializing an array will deduce dimension from the number of initialized elements int a[]={1,2,3; int a[3] printarray(std::cout,a); char str[]="world"; char str[6] 8

9 Summary "naked" Arrays Don't use naked arrays -> refactor to std::array one exception: program arguments of main() There are no dynamically sized arrays in C++, use vector Arrays degenerate to a naked pointer when passed as function argument then you always need to pass the length as well! C++20 will have std::span/std::view as array references Pointers to arrays work like random-access iterators ptr+dimension = end iterator 9

10 Dynamic Heap Memory Management new/delete, std::unique_ptr<t>, std::shared_ptr<t>

11 Heap Memory always rely on library classes for managing it (RAII) might be needed for creating object structures first think about library classes for your intended structure Look into the Boost library collection if std is insufficient for polymorphic factory functions to class hierarchies if you return a base-class "pointer" to one of its subclasses from functions 11

12 C++ heap memory basics: DO NOT! auto ptr=new int{5; std::cout << *ptr << '\n'; delete ptr; NEVER DO THIS C++ allows allocating objects on the heap auto ptr=new Type{argument; However, if done manually you are responsible for deallocation and risk undefined behavior: memory leaks dangling pointers double deletes no garbage collection happens, you must delete or leak 12

13 C++ heap memory real usage std::unique_ptr<x> factory(int i){ return std::make_unique<x>(i); Never-ever use plain pointers with heap allocation in modern C++ std::unique_ptr<t> obtained with make_unique<t> std::shared_ptr<t> obtained with make_shared<t> Never come to a situation where you have to explicitly "delete ptr;" (or generate a memory leak!) Always prefer local (stack-based or member) value-type variables over manually heap-allocated pointers. 13

14 std::unique_ptr<t> Used for unshared heap memory or for local stuff that must be on the heap this is a very very rare need, e.g., very large instances with limited stack space can be returned from a factory function only one owner! can wrap to-be-freed pointers from C functions when interfacing legacy code not best for class hierarchies, use std::shared_ptr<base> instead (unique_ptr base classes need virtual destructor) 14

15 No More "naked" Pointers: Resource Management with unique_ptr<t> it is guaranteed to be a Highlander: "There can be only one!" - no second reference #include <memory> transfer of ownership through return by value #include <iostream> std::unique_ptr<int> afactory(int i){ return std::make_unique<int>(i); int main(){ auto pi=afactory(42); std::cout << "*pi =" << *pi << '\n'; std::cout << "pi.valid? "<< std::boolalpha true << static_cast<bool>(pi) << '\n'; auto pj=std::move(pi); std::cout << "*pj =" << *pj << '\n'; transfer of ownership from lvalue std::cout << "pi.valid still? " << static_cast<bool>(pi) << '\n'; false 15

16 std::unique_ptr<t> for C pointers some C functions return pointers that must be deallocated with the function ::free(ptr) We can use unique_ptr to ensure that cxa_demangle() is such a function (compiler-specfic) std::string demangle(char const *name){ std::unique_ptr<char,decltype(&::free)> tobefreed{ cxxabiv1:: cxa_demangle(name,0,0,0),&::free; std::string result(tobefreed.get()); return result; Even when there would be an exception, free will be called on the returned pointer, no memory leak! 16

17 std::unique_ptr<t> for C pointers A unique_ptr storing the address of free() has an extra pointer and thus is twice the size. struct free_deleter{ template <typename T> void operator()(t *p) const { std::free(const_cast<std::remove_const_t<t>*>(p)); ; template <typename T> using unique_c_ptr=std::unique_ptr<t,free_deleter>; Better provide a deleter type as template argument no space overhead! inline std::string plain_demangle(char const *name){ if (!name) return "unknown"; unique_c_ptr<char const> tobefreed {abi:: cxa_demangle(name,0,0,0); std::string result(tobefreed?tobefreed.get():name); return result; 17

18 Guidelines for unique_ptr as member variable: to keep a polymorphic reference instantiated by the class or passed in as unique_ptr and transferring ownership as local variable: to implement RAII Resource Acquisition Is Initialization can provide custom "deleter" functor as second template argument to type that is called on destruction (see ::free usage) std::unique_ptr<t> const p{new T{; //local can not transfer ownership -> can not leak! 18

19 shared_ptr<t> + make_shared<t>() #include <memory> unique_ptr allows only one owner and can not be copied, only returned by value shared_ptr works more like Java's references, it can be copied and passed around and the last one ceasing to exist deletes the object You create shared_ptr and associated objects of type T using std::make_shared<t>(...) make_shared<t> allows all T's public constructor's parameters to be used 19

20 What is it for? If you really need heap-allocated objects, because you create your own object networks you can use shared_ptr<t> If you need to support run-time polymorphic container contents or class members that can not be passed as reference, e.g., because of lifetime issues Factory functions returning shared_ptrs for heap allocated objects but first check if alternatives are viable: (const) references as parameter types or class members (to surviving objects!) plain member objects or containers with plain class instances 20

21 No More "naked" Pointers: Resource Management with shared_ptr<t> If you really need to keep something explicit on the heap, use a factory like that: #include <memory> // or <boost/shared_ptr.hpp> #include <string> struct A{ A(int a,std::string b, char c){ ; example usages: int main(){ auto an_a=a_factory(); auto A_factory(){ return std::make_shared<a>(5,"hi",'a'); auto b=an_a; // second pointer to same object A c{*b; // copy ctor. auto another = std::make_shared<a>(c); // copy ctor on heap 21

22 No More "naked" Pointers: Class hierarchies with shared_ptr<t> use std::ostream, just as an example for a base class and a very primitive factory function, need to use concrete type with make_shared std::shared_ptr<std::ostream> os_factory(bool file){ if (file) return std::make_shared<std::ofstream>("hello.txt"); else return std::make_shared<std::ostringstream>(); a very simple usage scenario: int main(){ auto out = os_factory(false); if (out) (*out) << "hello world\n"; auto fileout = os_factory(true); if (fileout) (*fileout) << "Hello, world!\n"; fileout.reset(); // clears shared_ptr, deallocates stream object not really needed 22

23 Interesting side effects last shared_ptr handle destroyed will delete allocated object if instances of a class hierarchy are always represented by a shared_ptr<base> but created through make_shared<concrete>() the destructor no longer needs to be virtual shared_ptr memorizes concrete destructor for deletion on construction time in make_shared<concrete> shared_ptr can lead to object cycles no longer cleared, because of circular dependency need weak_ptr to break such cycles 23

24 Memory new T{ delete p; NULL (void*)0 < use nullptr Prefer unique_ptr/shared_ptr for heap-allocated objects over T*. Use std::vector and std::string instead of heap-allocated arrays. Peter Sommerlad

25 Example: Parents and Children shared_ptr cycles: weak_ptr/shared_from_this Create a class Person that represents a person Each Person knows about its parents (father/mother) if they are still alive Each Person can be married Each Person knows about its children both mother and father know about their children Observation: can not use direct members, would incur copying persons 25

26 Summary shared & weak ptr Be careful when creating object structures with shared_ptr -> avoid circular object dependencies require deliberate breaking to get rid of the instantiated objects use weak_ptr consequently keep all "living" objects in a separate data structure as shared_ptr and model dependencies through weak_ptr removing from "live list" destroys object Memory released when last weak_ptr expires 26

27 Model (part of) first biblical family Adam Eve sons: Abel, Cain, Seth represent Cain's murder of Abel represent Adams death represent Eve's death show a person with its name, parents' names and children's names 27

28 Steps and Effects Adam 1 Eve Adam 3 Eve Cain Abel Seth Cain Abel Seth Adam 2 Eve Adam 4 Eve Cain Abel Seth Cain Abel Seth 28

29 First cut on shared_ptr #include <memory> #include <string> #include <vector> #include <iosfwd> using PersonPtr=std::shared_ptr<class Person>; class Person { std::string name; std::vector<personptr> children; public: Person(std::string name):name{name{ void addchild(personptr child){ children.push_back(child); void print(std::ostream &) const; static PersonPtr makeperson(std::string name){ ; can define shared_ptr with incomplete type store shared_ptr in vector return std::make_shared<person>(name); #include "Person.h" #include <ostream> void Person::print(std::ostream& out) const { out << "Person: "<< name; out << "\n "; for(auto child:children){ out << child->name << ", "; out << '\n'; 29

30 first main() #include "Person.h" #include <iostream> void addson(std::string name,personptr adam, PersonPtr eva) { auto son = Person::makePerson(name); eva->addchild(son); adam->addchild(son); must add shared_ptr not object! int main() { auto adam=person::makeperson("adam"); adam->print(std::cout); auto eva=person::makeperson("eva"); eva->print(std::cout); addson("cain",adam, eva); addson("abel",adam, eva); addson("seth",adam, eva); adam->print(std::cout); eva->print(std::cout); // how to have Cain kill Abel? Person: Adam Person: Eva Person: Adam Cain, Abel, Seth, Person: Eva Cain, Abel, Seth, 30

31 Adam 2 Eve 2nd cut: "killing Abel" Cain Abel Seth know your parents class Person { std::string name; PersonPtr father; PersonPtr mother; std::vector<personptr> children; public: Person(std::string name, PersonPtr father,personptr mother) :name{name,father{father,mother{mother{ void addchild(personptr child){ children.push_back(child); std::string getname() const { return name; PersonPtr findchild(std::string name) const; void killchild(personptr child); void print(std::ostream &) const; static PersonPtr makeperson(std::string name, PersonPtr father={, PersonPtr mother={){ auto res = std::make_shared<person>(name,father,mother); if (father) father->addchild(res); if (mother) mother->addchild(res); return res; ; search and get rid of children 31

32 Adam 2 Eve 2nd cut: "killing Abel" void Person::print(std::ostream& out) const { out << "Person: "<< name ; out << " "<< (father?father->getname():"orphan"); out << " "<< (mother?mother->getname():"orphan"); out << "\n "; for(auto const &child:children){ out << child->name << ", "; out << '\n'; PersonPtr Person::findChild(std::string thename) const { using namespace std::placeholders; auto finder=[thename](personptr const &person){ return person->getname() == thename; ; auto it=find_if(children.begin(),children.end(),finder); if (it!= children.end()) return *it; return nullptr; void Person::killChild(PersonPtr child) { if (child){ children.erase(find(children.begin(),children.end(),child)); //if (child->father == )? know your parents search children, predicate as lambda nullptr means empty shared_ptr erase found object, shared_ptr == used Cain Abel Seth 32

33 Adam 2 Eve 2nd cut: "killing Abel" main() Cain Abel Seth #include "Person.h" #include <iostream> void addson(std::string name,personptr adam, PersonPtr eva) { auto son = Person::makePerson(name); eva->addchild(son); adam->addchild(son); int main() { auto adam=person::makeperson("adam"); adam->print(std::cout); auto eva=person::makeperson("eva"); eva->print(std::cout); addson("cain",adam, eva); addson("abel",adam, eva); addson("seth",adam, eva); adam->print(std::cout); eva->print(std::cout); // how to have Cain kill Abel? { auto abel=eve->findchild("abel"); eve->killchild(abel); adam->killchild(abel); abel->print(std::cout); eve->print(std::cout); // how can we kill Adam? last shared_ptr after killchild killing means forgetting all references Person: Adam orphan orphan Person: Eve orphan orphan Person: Adam orphan orphan Cain, Abel, Seth, Person: Eve orphan orphan Cain, Abel, Seth, Person: Abel Adam Eve Person: Eve orphan orphan Cain, Seth, 33

34 Problem: can not access shared_ptr class Person : public std::enable_shared_from_this<person> { CRTP solution: inherit from enable_shared_from_this CRTP pattern, pass own class as template argument access through shared_from_this() function can not do that in constructor or destructor! auto me=shared_from_this(); // or PersonPtr me=shared_from_this(); 34

35 Adam 3 Eve 3rd cut: "Adam can die" Cain Abel Seth class Person : public std::enable_shared_from_this<person> { std::string name; PersonPtr father; PersonPtr mother; std::vector<personptr> children; public: Person(std::string name,personptr father,personptr mother) :name{name,father{father,mother{mother{ // can not do shared_from_this here! // if(father) father->addchild(shared_from_this()); void addchild(personptr child){ children.push_back(child); std::string getname() const { return name; PersonPtr findchild(std::string name) const; void killchild(personptr child); void killme(); void print(std::ostream &) const; static PersonPtr makeperson(std::string name, PersonPtr father={, PersonPtr mother={){ auto res = std::make_shared<person>(name,father,mother); if (father) father->addchild(res); if (mother) mother->addchild(res); return res; ; inherit from enable_shared_from_this must still inform parents in factory function! disentangling circular object dependency by hand! void Person::killMe() { auto me=shared_from_this(); if (father) father->killchild(me); if (mother) mother->killchild(me); for(personptr son:children){ if (me == son->father) son->father.reset(); if (me == son->mother) son->mother.reset(); children.clear(); 35

36 Adam 3 Eve 3rd part of main() Cain Abel Seth must disentangle object circular reference before destroying... // how can we kill Adam and Eve? { adam->killme(); adam->print(std::cout); adam.reset(); eve->print(std::cout); auto cain=eve->findchild("cain"); if (cain) cain->print(std::cout); eve->killme(); // avoid memory leak eve->print(std::cout); eve.reset(); last reference to Adam forgotten last reference to Eve forgotten Cain doesn't have children, so no need for killme() Person: Adam orphan orphan Person: Eve orphan orphan Person: Adam orphan orphan Cain, Abel, Seth, Person: Eve orphan orphan Cain, Abel, Seth, Person: Abel Adam Eve Person: Eve orphan orphan Cain, Seth, Person: Adam orphan orphan Person: Eve orphan orphan Cain, Seth, Person: Cain orphan Eve Person: Eve orphan orphan 36

37 Problem: circular object reference using WeakPersonPtr=std::weak_ptr<class Person>; WeakPersonPtr father; // don't lock parent objects WeakPersonPtr mother; solution: make one direction based on weak_ptr internally Observer Pattern recognizes when shared_ptr no longer exists must call lock() to access underlying shared_ptr auto realfather=father.lock(); out <<(realfather?realfather->getname():"orphan"); 37

38 Adam 4 Eve 4th cut: "All can die" Cain Abel Seth PersonPtr Person::myLock() { try { auto me=shared_from_this(); return me; catch(std::bad_weak_ptr const &ex){ std::cout << "++++already dead? " << name<< '\n'; return PersonPtr{; // already dead void Person::killMe() { // here shared_from_this is possible auto me=mylock(); if (!me) return; // already dead auto realfather=father.lock(); if (realfather) realfather->killchild(me); auto realmother=mother.lock(); if (realmother) realmother->killchild(me); children.clear(); throws when called from destructor still need to inform parent, because it keeps a shared_ptr no more need to inform children, because they keep only weak_ptr Person::~Person() { std::cout << "killing me: "<< name << '\n'; //killme(); // can not call shared_from_this() in dtor! just to show what happens, not needed! 38

39 Adam 4 Eve 4th cut: main() int main() { auto adam=person::makeperson("adam"); adam->print(std::cout); auto eve=person::makeperson("eve"); eve->print(std::cout); addson("cain",adam, eve); addson("abel",adam, eve); addson("seth",adam, eve); adam->print(std::cout); eve->print(std::cout); // Cain kills Abel: need to remove from parents { auto abel=eve->findchild("abel"); eve->killchild(abel); adam->killchild(abel); abel->print(std::cout); eve->print(std::cout); // kill Adam by forgetting last reference { std::cout << "killing Adam:\n"; adam->print(std::cout); adam.reset(); eve->print(std::cout); auto cain=eve->findchild("cain"); if (cain) cain->print(std::cout); eve.reset(); if (cain) cain->print(std::cout); no more need to disentangle last reference to Adam forgotten last reference to Eve forgotten Person: Adam orphan orphan Person: Eve orphan orphan Person: Adam orphan orphan Cain, Abel, Seth, Person: Eve orphan orphan Cain, Abel, Seth, Person: Abel Adam Eve killing me: Abel Person: Eve orphan orphan Cain, Seth, killing Adam: Person: Adam orphan orphan Cain, Seth, killing me: Adam Person: Eve orphan orphan Cain, Seth, Person: Cain orphan Eve killing me: Eve killing me: Seth Person: Cain orphan orphan killing me: Cain Cain Abel Seth 39

40 Summary Use it for containers of polymorphic objects with an abstract Base class std::vector<std::shared_ptr<base>> create individual instances of concrete subclasses in a factory function with make_shared<subclass>(...) can pass arguments as with Subclass' constructor Prefer direct members/values instead of heap allocated objects, if possible! 40