Programmeringsmetodik, dt079g

Lösningsförslag tentamen 2004-03-16

För uppgifterna 1-7

Tentamensdokumentet hittar du här>>

1. Betrakta

   void f( const T & obj );
   

   Kompilatorn matchar alla anrop till f

   f( (typ) x );
   

   Där det finns en enargumentskonstruerare för (typ). Exempelvis

   struct C{
     C(int i);
   };
   
   void f(const C& o);
   
   //matchas med ex
   void g(){
     f( 5 ); // implicit typomvandling/konstruktion
   }
   

2. Inkapsling se litteratur. class public private. Klassbegreppet är kärnan i inkapsling som implem,enteras mha private och public.
3. Är-relationen ska förklaras med ett korrekt diagram(medlemmarna är oviktiga) för 4 poäng.
4. a) Separatkompilering är svårt pga mallklasser och mallfunktioner måste instansieras. Dvs de har ingen konkret typ innan instansieringen.
   b) Mallinstansiering kommer i form av instansdeklarationer eller vanligare, variabeldeklarationer typ vector<int> v; . Instansieringen sker i kompileringssteget, i synnerhet det steg som innehåller instansdeklarationen. Där blir malltyperna kända och typen kann konkretiseras.
5. Kärnan i lösningen är det publika arvet av streamable

   struct card_suit: public streamable{
   	 string suit;
      card_suit(string s):suit(s){}
   	 string to_string() const { return suit; }
   };
   struct card_value: public streamable{
      string value;
   	 card_value(string s):value(s){}
   	 string to_string() const { return value; }
   };
   struct card: public card_value, public card_suit{
      card(string value, string suit):card_value(value), card_suit(suit){ }
   	 string to_string() const {
   	 	 return card_value::to_string() + " of "+ card_suit::to_string();
   	 }
   };
   int main(){
     card c( "2", "spades" );
   	cout << c;
   	cwrite( c );
   }
   //och cwrite får den triviala definitionen
   void cwrite(const streamable & s){
     cout<%lt;s;
   }
   

   Statisk bindning kan inte användas för att få en liknande designlösning. En lösning med statisk bindning skulle innefatta en operatordefinition + funktionsdefinition för cwrite för varje inblandad typ.
6. Inga syntaktiska fel finns i programmet. För kompilering krävs #include<iostream> och using namespace std;. Resultatet är

   Constructor B2
   Constructor B1
   Constructor D
   5  4  3
   Destructor D
   Destructor B1
   Destructor B2
   

   Konstruktionsordningen definieras i arvsdeklarationen och inte av konstruerarnas superanrop/ initieringssatser.

7. vector<int> v;
   v.reserve( 5 );
   v.assign( 3, 1 );
   cout<< *v.begin() << *v.rbegin() << v.size() <<v.capacity()<<endl;
   v.erase( v.begin() );
   v.erase( v.begin(), v.end()); // alias v.clear();
   

8. #include<map>
   #include<iostream>
   #include<algorithm>
   #include<string>
   using namespace std;
   
   typedef multimap<string, string> PhoneBook;
   typedef PhoneBook::iterator PhoneEntry;
   typedef pair<string, string> Phone;
   
   // utskrift
   void PrintPhoneEntry( Phone p){
   	cout<<p.first<<", "<<p.second<<endl;
   }
   int main(){
     PhoneBook pbk;
     // insättning
     pbk.insert( Phone("Martin", "555-1443") );
     // sökning
     PhoneEntry i = pbk.find( "Martin" );
     // utskrift
     for_each( pbk.begin(), pbk.end(), PrintPhoneEntry );
     return 0;
   }
     // pbk[xxx] går inte eftersom iteratorerna 
     // till map/multimap är bidirectional och
     // inte random access
   
   

9. Funktionsobjekt - En klass/Struct med operator() överlagrad
   Containertyperna använder funktionsobjekt som "Traits" för att ordna element internt, 
     ej Random Access containers
   De olika funktionsobjektstyperna se stl, de är många, ge ett urval
   struct UnPred{ UnPred(int _N):N(_N){}
      int N;
      bool operator()(int Val){  return Val<N; }
   };

10. (Input||Output, *it, it++) 
          Forward,
               Bidirectional, it--
    		Random Access, it+_diff / it[off]

11. a) se uppg 8
    b) ostream_iterator osi(cout, '\n');
       copy( cont.begin(), cont.end(), osi);

12. Med mängd avses nedan ForwardIteratorer begin/end
    
    find_if - sök i mängd med predikat, exempel trivialt efter applikation
    count   - räkna antal i mängd efter värde ex räkna antal int( 1 ) i en vector<int>
    transform - omvandla mängd enl omvandlingsfuntion f(T&element)
    accumulate - summering med startvärde över mängd eller egen vald operation