ISU+Ov10

Del 1 Copy constructor og asignment operator er gjort private da vi ikke ønsker at andre skal tilgå dem og ædre på str_.

code using namespace std;
 * 1) ifndef SMARTSTRING_H
 * 2) define SMATSTRING_H
 * 3) include

class SmartString { public: SmartString(string* str):str_(str){} ~SmartString {   delete str_; } string* get {    return str_; } string* operator-> {   return str_; } string& operator* {   return *str_; }

private: /*Erklære copy construntor * og assignment * private, da vi ikke vil have andre til at pille ved copy og point */ string* str_; SmartString(const SmartString& other){} SmartString* operator=(const SmartString& other){} };

code What exactly does the operator -> do? Den gør at vi kan tilgå funktioner som er i string i stedet for at tilgå medlemsfunktionerne som er i vores klasse

VEd hjælp af RAII kan vi sikre den dynamiske allokering og dermed kan vi få SMartString til at fremstå som en raw pointer ved at overloade. Man kan dermed bruge SmartString på de steder hvor vi ville forvænte at der er en raw pointer.

Til hjælp blev benyttet " http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Smart_Pointer" ud fra denne er selve opbygning og besvarelse gjort

Del 2 Vi implementere nu en counter i vores Smart pointer fra opgave 1 for at få dette til at fungere måtte vi foretage lidt ændringer i koden, de ses neden under code using namespace std;
 * 1) ifndef SMARTSTRING_H
 * 2) define SMARTSTRING_H
 * 3) include

class SmartString { public: SmartString(string* str):str_(str), counter_(new unsigned int(1)){} ~SmartString {   (*counter_)--; if(!counter_) {     delete str_; delete counter_; } }

SmartString(const SmartString& other) {   counter_ = other.counter_; str_ = other.str_; (*counter_)++; }

SmartString& operator=(const SmartString& other) {   if(this!= &other) {     (counter_)--; {     delete counter_; delete str_; }   counter_ = other.counter_; str_ = other.str_; (counter_)++; }

return *this;

}

string* get {    return str_; } string* operator-> {   return str_; } string& operator* {   return *str_; }

private: /*Erklære copy construntor * og assignment * private, da vi ikke vil have andre til at pille ved copy og point */ string* str_; unsigned int *counter_; };


 * 1) endif

code

Del 3(Optional)

Del 4

code


 * 1) include 

int main {   boost::shared_ptr stringPtr1(new std::string(" boost_ptr1")); boost::shared_ptr stringPtr2(new std::string(" boost_ptr2")); //vi opretter 2 string pointere der indeholder boost_ptr1 og boost_ptr2

std::cout << *stringPtr1 << std::endl; std::cout << *stringPtr2 << std::endl; // vi udskriver indholdet af de to strings ved at bruge overstående kode

std::cout << stringPtr1.use_count << std::endl; //Udskriver use_count, den står på 1 her

stringPtr2 = stringPtr1; //tjekker at assignment operatoren virker

std::cout << stringPtr1.use_count << std::endl; //Udskriver use_count, den står på 2 her

std::cout << *stringPtr1 << "  " << *stringPtr2 << std::endl; //tjekker ad der står det samme i stringPtr1 og 2

boost::shared_ptr stringPtr3(stringPtr1); //Opretter en ny string hvor copy constructoren benyttes

std::cout << stringPtr1.use_count << std::endl; //Udskriver use_count, den står på 3 her.

std::cout << *stringPtr1 << "  " << *stringPtr3 << std::endl; //tjekker at der står det samme i stringPtr1 og 3

stringPtr2.reset; //Vi deleter nu string2 for at tjekke counteren tæller ned igen

std::cout << stringPtr1.use_count << std::endl; //Her er tælleren så talt ned til 2 igen.

return 0; }

code

Del 5 What do you consider a resource?
 * Filer, CPU, Hukommelse

In which situations do you foresee challenges with resources and how would they be handled?
 * I ens program kan man have problemer med at resources skal frigives igen, dette er en vigtig ing at huske
 * Under vejs i programmet sker det at vi opretter flere udveje. Vi er derfor nød til at nedlægge disse i de situationer. De skal som hovedregel nedlægges af dem der laver dem.

In Particular regarding memory, when would you be able eliminate the need for allocations. Or when is it a must that something is allocated (on heap)?
 * Om vi arbejder med noget som vi ved præcist eller cirka hvor meget skal bruge af hukommelsen, altså noget statisk, i dette tilfælde kan vi gå ind og styre allokering og hukommelse.
 * Om vi har behov for dynamisk at kunne allokere benytter vi heapen, dette er oftest ved nye objekter. Tilfældet kan også være at vi ikke kender størrelsen på det som vi skal allokere.