Overview. Chapter 18 Vectors and Arrays. Reminder. vector. Bjarne Stroustrup

Transcription

1 Chapter 18 Vectors ad Arrays Bjare Stroustrup Vector revisited How are they implemeted? Poiters ad free store Destructors Iitializatio Copy ad move Arrays Array ad poiter problems Chagig size Templates Rage checkig ad exceptios Overview Stroustrup/Programmig Remider Why look at the vector implemetatio? To see how the stadard library vector really works To itroduce basic cocepts ad laguage features Free store (heap) Copy ad move Dyamically growig data structures To see how to directly deal with memory To see the techiques ad cocepts you eed to uderstad C Icludig the dagerous oes To demostrate class desig techiques To see examples of eat code ad good desig vector // a very simplified vector of doubles (as far as we got i chapter 17): class vector it sz; // the size double* elem; // poiter to elemets vector(it s) :szs, elemew double[s] // costructor // ew allocates memory ~vector() delete[ ] elem; // destructor // delete[] deallocates memory double get(it ) retur elem[]; // access: read void set(it, double v) elem[]=v; // access: write it size() cost retur sz; ; // the umber of elemets Stroustrup/Programmig 4 Stroustrup/Programmig 5 1

2 Iitializatio: iitializer lists Iitializatio: iitializer lists We would like simple, geeral, ad flexible iitializatio So we provide suitable costructors, icludig class vector vector(it s); // costructor (s is the elemet cout) We would like simple, geeral, ad flexible iitializatio So we provide suitable costructors vector::vector(it s) // costructor (s is the elemet cout) :szs, elemew double[s] for (it i=0; i<sz; ++i) elem[i]=0; ; vector(std::iitializer_list<double> lst); // iitializer-list costructor vector v1(20); // 20 elemets, each iitialized to 0 vector v2 1,2,,4,5; // 5 elemets: 1,2,,4,5 vector::vector(std::iitializer_list<double> lst) // iitializer-list costructor :szlst.size(), elemew double[sz] std::copy(lst.begi(),lst.ed(),elem); // copy lst to elem vector v1(20); // 20 elemets, each iitialized to 0 vector v2 1,2,,4,5; // 5 elemets: 1,2,,4,5 Stroustrup/Programmig 6 Stroustrup/Programmig 7 Iitializatio: lists ad sizes If we iitialize a vector by 17 is it 17 elemets (with value 0)? 1 elemet with value 17? By covetio use () for umber of elemets for elemets For example vector v1(17); // 17 elemets, each with the value 0 vector v2 17; // 1 elemet with value 17 Iitializatio: explicit costructors A problem A costructor takig a sigle argumet defies a coversio from the argumet type to the costructor s type Our vector had vector::vector(it), so vector v1 = 7; // v1 has 7 elemets, each with the value 0 void do_somethig(vector v) do_somethig(7); // call do_somethig() with a vector of 7 elemets This is very error-proe. Uless, of course, that s what we wated For example complex<double> d = 2.; // covert from double to complex<double> Stroustrup/Programmig 8 Stroustrup/Programmig 9 2

3 Iitializatio: explicit costructors A solutio Declare costructors takig a sigle argumet explicit uless you wat a coversio from the argumet type to the costructor s type class vector explicit vector(it s); // costructor (s is the elemet cout) ; vector v1 = 7; // error: o implicit coversio from it void do_somethig(vector v); do_somethig(7); // error: o implicit coversio from it Stroustrup/Programmig 10 A problem Copy does t work as we would have hoped (expected?) void f(it ) vector v(); vector v2 = v; vector v; v = v; // defie a vector // what happes here? // what would we like to happe? // what happes here? // what would we like to happe? Ideally: v2 ad v become copies of v (that is, = makes copies) Ad all memory is retured to the free store upo exit from f() That s what the stadard vector does, but it s ot what happes for our still-too-simple vector Stroustrup/Programmig 11 Naïve copy iitializatio (the default) By default copy meas copy the data members void f(it ) vector v1(); vector v2 = v1; v1: // iitializatio: // by default, a copy of a class copies its members // so sz ad elem are copied Naïve copy assigmet (the default) void f(it ) vector v1(); vector v2(4); v2 = v1; v1: // assigmet: // by default, a copy of a class copies its members // so sz ad elem are copied 2 d 1 st v2: v2: 4 Disaster whe we leave f()! v1 s elemets are deleted twice (by the destructor) Stroustrup/Programmig 12 Disaster whe we leave f()! v1 s elemets are deleted twice (by the destructor) memory leak: v2 s elemets are ot deleted Stroustrup/Programmig 1

4 Copy costructor (iitializatio) Copy with copy costructor class vector it sz; double* elem; vector(cost vector&) ; ; // copy costructor: defie copy (below) vector::vector(cost vector& a) :sza.sz, elemew double[a.sz] // allocate space for elemets, the iitialize them (by copyig) for (it i = 0; i<sz; ++i) elem[i] = a.elem[i]; void f(it ) vector v1(); vector v2 = v1; v1: v2: // copy usig the copy costructor // the for loop copies each value from v1 ito v2 The destructor correctly deletes all elemets (oce oly for each vector) Stroustrup/Programmig 14 Stroustrup/Programmig 15 Copy assigmet class vector it sz; double* elem; vector& operator=(cost vector& a); // copy assigmet: defie copy (below) ; x=a; x: a: 1 st d Operator = must copy a s elemets Memory leak? (o) Copy assigmet vector& vector::operator=(cost vector& a) // like copy costructor, but we must deal with old elemets // make a copy of a the replace the curret sz ad elem with a s double* p = ew double[a.sz]; // allocate ew space for (it i = 0; i<a.sz; ++i) p[i] = a.elem[i]; // copy elemets delete[ ] elem; // deallocate old space sz = a.sz; // set ew size elem = p; // set ew elemets retur *this; // retur a self-referece // The this poiter is explaied i Lecture 19 // ad i Stroustrup/Programmig 16 Stroustrup/Programmig 17 4

5 Copy with copy assigmet void f(it ) vector v1 6,24,42; vector v2(4); v2 = v1; v1: v2: // assigmet st delete[ ]d by = No memory Leak Copy termiology Shallow copy: copy oly a poiter so that the two poiters ow refer to the same object What poiters ad refereces do Deep copy: copy what the poiter poits to so that the two poiters ow each refer to a distict object What vector, strig, etc. do Requires copy costructors ad copy assigmets for cotaier classes Must copy all the way dow if there are more levels i the object Copy of x: x: Copy of x: x: 2 d y: Shallow copy y: Copy of y: Deep copy Stroustrup/Programmig 18 Stroustrup/Programmig 19 Deep ad shallow copy v1: 2 v2: vector<it> v1 2,4; vector<it> v2 = v1; // deep copy (v2 gets its ow copy of v1 s elemets) v2[0] = ; // v1[0] is still 2 4 Cosider vector fill(istream& is) vector res; Move for (double x; is>>x; ) res.push_back(x); retur res; // returig a copy of res could be expesive // returig a copy of res would be silly! it b = 9; it& r1 = b; r2: r1: b: it& r2 = r1; // shallow copy (r2 refers to the same variable as r1) r2 = 7; // b becomes 7 Stroustrup/Programmig void use() vector vec = fill(ci); use vec Stroustrup/Programmig 21 5

6 What we wat: Move Move Costructor ad assigmet Before retur res; i fill() Defie move operatios to steal represetatio vec: uiitialized res: After retur res; (after vector vec = fill(ci); ) class vector it sz; double* elem; vector(vector&&); && idicates move // move costructor: steal the elemets vec: res: 0 ullptr vector& operator=(vector&&); // move assigmet: // destroy target ad steal the elemets //... ; Stroustrup/Programmig 22 Stroustrup/Programmig 2 Move implemetatio Move implemetatio vector::vector(vector&& a) // move costructor :sza.sz, elema.elem // copy a s elem ad sz a.sz = 0; // make a the empty vector a.elem = ullptr; vector& vector::operator=(vector&& a) delete[] elem; elem = a.elem; sz = a.sz; a.elem = ullptr; a.sz = 0; retur *this; // deallocate old space // copy a s elem ad sz // make a the empty vector // move assigmet // retur a self-referece (see 17.10) Stroustrup/Programmig 24 Stroustrup/Programmig 25 6

7 Essetial operatios Costructors from oe or more argumets Default costructor Copy costructor (copy object of same type) Copy assigmet (copy object of same type) Move costructor (move object of same type) Move assigmet (move object of same type) Destructor If you defie oe of the last 5, defie them all Arrays Arrays do t have to be o the free store char ac[7]; it max = 100; it ai[max]; // global array lives forever i static storage it f(it ) char lc[20]; // local array lives util the ed of scope o stack it li[60]; double lx[]; // error: a local array size must be kow at compile time // vector<double> lx(); would work Stroustrup/Programmig 26 Stroustrup/Programmig 27 Address of: & You ca get a poiter to ay object ot just to objects o the free store it a; char ac[20]; void f(it ) it b; it* p = &b; a: // poiter to idividual variable ac: p = &a; // ow poit to a differet variable char* pc = ac; // the ame of a array ames a poiter to its first elemet pc = &ac[0]; // equivalet to pc = ac pc = &ac[]; // poiter to ac s th elemet (startig at 0 th ) // warig: rage is ot checked p: Stroustrup/Programmig pc: 28 Arrays (ofte) covert to poiters void f(it pi[ ]) // equivalet to void f(it* pi) it a[ ] = 1, 2,, 4 ; it b[ ] = a; // error: copy is t defied for arrays b = pi; // error: copy is t defied for arrays. Thik of a // (o-argumet) array ame as a immutable poiter pi = a; // ok: but it does t copy: pi ow poits to a s first elemet // Is this a memory leak? (maybe) it* p = a; // p poits to the first elemet of a it* q = pi; // q poits to the first elemet of a pi: 1 st 2 d a: p: q: Stroustrup/Programmig 29 7

8 Arrays do t kow their ow size void f(it pi[ ], it, char pc[ ]) // equivalet to void f(it* pi, it, char* pc) // warig: very dagerous code, for illustratio oly, // ever hope that sizes will always be correct char buf1[200]; strcpy(buf1,pc); // copy characters from pc ito buf1 // strcpy termiates whe a '\0' character is foud // hope that pc holds less tha 200 characters strcpy(buf1,pc,200); // copy 200 characters from pc to buf1 // padded if ecessary, but fial '\0' ot guarateed it buf2[00]; // you ca t say it buf2[]; is a variable if (00 < ) error("ot eough space"); for (it i=0; i<; ++i) buf2[i] = pi[i]; // hope that pi really has space for // its; it might have less Stroustrup/Programmig 0 Be careful with arrays ad poiters char* f() char ch[20]; char* p = &ch[90]; *p = 'a'; // we do t kow what this will overwrite char* q; // forgot to iitialize *q = 'b'; // we do t kow what this will overwrite retur &ch[10]; // oops: ch disappears upo retur from f() // (a ifamous daglig poiter ) void g() char* pp = f(); *pp = 'c'; // we do t kow what this will overwrite // (f s ch is goe for good after the retur from f) Stroustrup/Programmig 1 Why bother with arrays? Types of memory It s all that C has I particular, C does ot have vector There is a lot of C code out there Here a lot meas N*1B lies There is a lot of C++ code i C style out there Here a lot meas N*100M lies You ll evetually ecouter code full of arrays ad poiters They represet primitive memory i C++ programs We eed them (mostly o free store allocated by ew) to implemet better cotaier types Avoid arrays wheever you ca They are the largest sigle source of bugs i C ad (uecessarily) i C++ programs They are amog the largest sources of security violatios, usually (avoidable) buffer overflows Stroustrup/Programmig 2 vector glob(10); vector* some_fct(it ) vector v(); vector* p = ew vector(); retur p; // global vector lives forever // local vector lives util the ed of scope // free-store vector lives util we delete it void f() vector* pp = some_fct(17); delete pp; // deallocate the free-store vector allocated i some_fct() it s easy to forget to delete free-store allocated objects so avoid ew/delete whe you ca (ad that s most of the time) Stroustrup/Programmig 8

9 Vector (primitive access) // a very simplified vector of doubles: vector v(10); for (it i=0; i<v.size(); ++i) v.set(i,i); cout << v.get(i); for (it i=0; i<v.size(); ++i) v[i]=i; cout << v[i]; 10 // pretty ugly: // we re used to this: Vector (we could use poiters for access) // a very simplified vector of doubles: class vector it sz; // the size double* elem; // poiter to elemets explicit vector(it s) :szs, elemew double[s] // costructor double* operator[ ](it ) retur &elem[]; // access: retur poiter ; vector v(10); for (it i=0; i<v.size(); ++i) // works, but still too ugly: *v[i] = i; // meas *(v[i]), that is, retur a poiter to // the i th elemet, ad dereferece it cout << *v[i]; Stroustrup/Programmig 4 Stroustrup/Programmig 5 Vector (we use refereces for access) // a very simplified vector of doubles: class vector it sz; // the size double* elem; // poiter to elemets explicit vector(it s) :szs, elemew double[s] // costructor double& operator[ ](it ) retur elem[]; // access: retur referece ; vector v(10); for (it i=0; i<v.size(); ++i) v[i] = i; cout << v[i]; 10 // works ad looks right! // v[i] returs a referece to the i th elemet Poiter ad referece You ca thik of a referece as a automatically derefereced immutable poiter, or as a alterative ame for a object Assigmet to a poiter chages the poiter s value Assigmet to a referece chages the object referred to You caot make a referece refer to a differet object it a = 10; it* p = &a; // you eed & to get a poiter *p = 7; // assig to a through p // you eed * (or [ ]) to get to what a poiter poits to it x1 = *p; // read a through p it& r = a; r = 9; it x2 = r; p = &x1; r = &x1; // r is a syoym for a // assig to a through r // read a through r // you ca make a poiter poit to a differet object // error: you ca t chage the value of a referece Stroustrup/Programmig 6 Stroustrup/Programmig 7 9

10 Next lecture We ll see how we ca chage vector s implemetatio to better allow for chages i the umber of elemets. The we ll modify vector to take elemets of a arbitrary type ad add rage checkig. That ll imply lookig at templates ad revisitig exceptios. Stroustrup/Programmig 8 10