Programmieren, Algorithmen und Datenstrukturen 2 (Vorlesung 10)

Start: Seite 23

Zuweisungsoperation

//Abfangen des Falles, dass man von dem gleichen Vektor in sich selbst kopieren/verweisen will
if (this==&a) return *this;

Ein leeres Object vom Typ myVector

Der new-Operator kann nur initialisierten Speicher zur Verfügung stellen. Deshalb muss er wissen, für welchen Typ der Speicher reserviert werden soll. Da mann für Templates allerdings uninitialisierten Speicher reservieren muss, werden extra „allocate“-Typen erstellt, die mit „rohem“ Speicher umgehen können.

Templates

• Erweiterung des reinen „double“-myVectors um alle gängigen Typen
• Wechsel vom normalen Typen zum parametrisierten Typen
• Übergeben der Typen in Kopf und Rumpf als Parameter (flexibel)
• „Generische Programmierung“ = Verfahren zur Entwicklung wiederverwendbarer Software-Bibliotheken. Dabei werden Funktionen möglichst allgemein entworfen, um für unterschiedliche Datentypen und Datenstrukturen verwendet werden zu können.
• Möglich für Methoden, Funktionen und Klassen
• Befehls- und Indexoperationen lassen sich auch bei Templates überladen

template class Name_value { // Template swap für alle Klassen
private:
	string name;
	Name_value( string name, X value );
	Name_value& operator=( const Name_value& a );
	X val;
public:
	// …
};

// Aufrufe
Name_value nvi( string("Zwerge"), 7 );
Name_value nvb( string("Checked"), true );
Name_value nvc( string("Tabulator"), '\t' );
};

template void swap( X& a, X& b ) {
	X tmp = a; a = b; b = tmp;
}

//Aufruf
int v(123); int w(-7); swap( v, w );

Fehler:

• Was passiert wenn kein Standardkonstruktor angelegt wird für Typ T?

// Fehler, Standardkonstruktor für den selbst definierten Typen <em>"No_default"</em> fehlt
// wenn ein Default-Wert mitgegeben wird, dann ist es kein Problem
myVector v2( 10 );
// besser : myVector v2(10,1.0)

MyVector-Klasse als Template

/*
 * File:   main.cpp
 * Author: maximilian.krieg
 *
 * Created on 26. April 2012, 09:02
 */

/* template.cpp
   osk-2011-dez
   PAD2, ein einfaches vector Template selbst gemacht
 */

#include
#include "error.h"
using namespace std;
using std::runtime_error;

template class myVector {
    int sz;
    int space;
    T* elem;

public:

    myVector() : sz(0), space(0), elem(0) {
    }
    explicit myVector(int, T);

    myVector(const myVector&);
    myVector& operator=(const myVector&);
    ~myVector();
    int size() const;
    int capacity() const;
    T& operator[](int);
    void reserve(int);
    void resize(int, T);
    void push_back(const T&);
};

template myVector::myVector(int s, T val = T()) {
}

template myVector::myVector(const myVector& a) {
}

template myVector& myVector::operator=(const myVector& a) {

}

template myVector::~myVector() {

}

template void myVector::reserve(int newspace) {
    if (newspace     T* p = new T[newspace]; // mit new Speicher allokieren
    for (int i = 0; i < sz; ++i) p[i] = elem[i]; // Elemente kopieren
    delete[] elem; // alten Speicher freigeben
    elem = p;
    space = newspace;
}

template void myVector::resize(int newsize, T val = T()) {
    reserve(newsize);
    for (int i = sz; i < newsize; ++i) elem[i] = val;
    sz = newsize; 
}

template void myVector::push_back(const T& val) {     
    if (space == 0) reserve(8);    
    else 	if (sz == space) 	
    reserve(space * 2);    
    elem[sz] = val;     
    ++sz; 
}

template T& myVector::operator[](int n) {     
    if (0 > n || sz    
    return elem[n];
}

/*
 *
 */
int main() {
    myVector v1;
    v1.push_back(1);
    cout << v1[0];
    return 0;
}

Speicherreservierung

• Speicher für einen unbekannten Typen wird reserviert (Allocator)
• Der Typ allocator aus der StdLib stellt nicht-initialisierten Speicher bereit
• Nun wird für myVector Objekte statt new der Allokator namens alloc vom Typ allocator<T> verwendet

Begriffe / terminologie

• Template/Parameter: Umsetzen zur Build-Time
• Abgeleitete Klassen/virtuelle Methoden: Umsetzen zur Run-Time

Ende: Seite 43