main.cpp

#include <iostream>
#include "vector.hpp"
#include "set.hpp"
using namespace std;

int main()
{
	cout << "   MEN\x9a \n";
	cout << "''''''''''''''''''\n\n";
	cout << "[1] Name Suchen\n";
	cout << "[2] Neuer Name\n";
	set<int> data_base;
	data_base.insert(55); //<-- ohne die Zeile geht alles ohne Errors oder Warnungen

	return 0;
}

vector.hpp

#ifndef VECTOR_HPP_INCLUDED
#define VECTOR_HPP_INCLUDED

#include "size.hpp"

template <class T>
class vector : public size<T>
{
    public:
    vector(int size);
    vector(const vector &rhs);
    ~vector();
    int GetSize() {return m_size;}
    T &operator[] (int index);
    vector &operator= (const vector &rhs);
    void grow(int fields);
    void moveDown(int pos); //ohne Nullstelle!!!
    private:
    T *m_data;
    size_t m_size;
};

template <class T>
vector<T>::vector(int size)
:m_size(size)
{
    m_data=new T[m_size];
}

template <class T>
vector<T>::vector(const vector &rhs)
:m_size(rhs.m_size)
{
    m_data=new T[m_size];
    for (int i=0;i<m_size;i++)
    {
        m_data[i]=rhs.m_data[i];
    }
}

template <class T>
vector<T>::~vector()
{
    delete []m_data;
}

template <class T>
T &vector<T>::operator[] (int index)
{
    return m_data[index];
}

template <class T>
vector<T> &vector<T>::operator= (const vector &rhs)
{
    if (&rhs!=this)
    {
        delete []m_data;
        m_data=NULL;
        m_size=rhs.m_size;
        m_data=new T[m_size];
        for (int i=0;i<m_size;i++)
        {
            m_data[i]=rhs.m_data[i];
        }
    }
    return *this;
}

template <class T>
void vector<T>::grow(int fields)
{
    change_size(m_data,m_size,fields);
}

template <class T>
void vector<T>::moveDown(int pos)
{
    for (int i=pos-1;i<m_size;i++)
    {
        m_data[i]=m_data[i+1];
    }
    m_size--;
}

#endif // VECTOR_HPP_INCLUDED

size.hpp

#ifndef SIZE_HPP_INCLUDED
#define SIZE_HPP_INCLUDED

#include <iostream>
#include <string>

template <class T>
class size
{
    public:
    size();
    virtual ~size();
    void change_size(T &array,int length_old,int extension);
};

template <class T>
size<T>::size()
{

}

template <class T>
size<T>::~size()
{

}

template <class T>
void size<T>::change_size(T &array,int length_old,int extension)
{
    T *cache=new T[length_old];
    for (int i=0;i<length_old;i++)
    {
        cache[i]=array[i];
    }
    delete []array;
    array=NULL;
    array=new T[length_old+extension];
    for (int i=0;i<(length_old+extension);i++)
    {
        array[i]=cache[i];
    }
    delete []cache;
}

#endif // SIZE_HPP_INCLUDED

set.hpp

#ifndef SET_HPP_INCLUDED
#define SET_HPP_INCLUDED

#include "vector.hpp"

template <class T>
class set
{
    public:
    set();
    ~set();
    T *find(const T &toFind);
    bool has(const T &toFind);
    void insert(const T &toInsert);
    void remove(const T &toRemove);

    private:
    int findIndex(const T &toFind);
    vector<T> m_data;
    int m_size;
};

template <class T>
set<T>::set()
:m_data(10)
{
    m_size=10;
}

template <class T>
set<T>::~set()
{

}

template <class T>
T *set<T>::find(const T &toFind)
{
    int found=findIndex(toFind);
    if (found!=-1)
    {
        return &m_data[found];
    }
    else
    {
        return 0;
    }
}

template <class T>
bool set<T>::has(const T &toFind)
{
    return find(toFind)!=0;
}

template <class T>
void set<T>::insert(const T &toInsert)
{
    if (!has(toInsert))
    {
        if (m_size==m_data.GetSize())
        {
            m_data.grow(10);
        }
        m_data[m_size]=toInsert;
        m_size++;
    }
}

template <class T>
int set<T>::findIndex(const T &toFind)
{
    for (int i=0;i<m_size;i++)
    {
        if (toFind==m_data[i])
        {
            return i;
        }
    }
    return -1;
}

template <class T>
void set<T>::remove(const T &toRemove)
{
    int found=findIndex(toRemove);
    if (found!=-1)
    {
        m_data.moveDown(found);
    }
}

#endif // SET_HPP_INCLUDED

ERRORS:

-------------- Build: Debug in Telefonbuch ---------------
Compiling: main.cpp
vector.hpp: In member function void vector<T>::grow(int) \[with T = int\]': set.hpp:63: instantiated fromvoid set<T>::insert(const T&) [with T = int]'
main.cpp:13: instantiated from here
vector.hpp:75: error: no matching function for call to vector<int>::change\_size(int*&, size\_t&, int&)' size.hpp:30: note: candidates are: void size<T>::change_size(T&, int, int) \[with T = int\] size.hpp: In member functionvoid size<T>::change_size(T&, int, int) [with T = int]':
vector.hpp:75: instantiated from void vector<T>::grow(int) \[with T = int\]' set.hpp:63: instantiated fromvoid set<T>::insert(const T&) [with T = int]'
main.cpp:13: instantiated from here
size.hpp:34: error: invalid types int\[int\]' for array subscript size.hpp:36: error: type \int' argument given to `delete', expected pointer
size.hpp:37: warning: converting to non-pointer type int' from NULL size.hpp:38: error: invalid conversion from \int*' to `int'
size.hpp:41: error: invalid types `int[int]' for array subscript
Process terminated with status 1 (0 minutes, 0 seconds)
11 errors, 1 warnings

Großes Dankeschön schon mal im Voraus.

template <class T>
void size<T>::change_size(T **array,int length_old,int extension)
{
    T *cache=new T[length_old];
    for (int i=0;i<length_old;i++)
    {
        cache[i]=(*array)[i];
    }
    delete [](*array);
    *array=0;
    *array=new T[length_old+extension];
    for (int i=0;i<length_old;i++)
    {
        (*array)[i]=cache[i];
    }
    delete []cache;
}

Es kommen jetzt auch nur noch 4 Errors:

-------------- Build: Debug in Telefonbuch ---------------
Compiling: main.cpp
vector.hpp: In member function void vector<T>::grow(int) \[with T = int\]': set.hpp:63: instantiated fromvoid set<T>::insert(const T&) [with T = int]'
main.cpp:13: instantiated from here
vector.hpp:75: error: no matching function for call to `vector<int>::change_size(int*&, size_t&, int&)'
size.hpp:30: note: candidates are: void size<T>::change_size(T**, int, int) [with T = int]
Process terminated with status 1 (0 minutes, 0 seconds)
4 errors, 0 warnings

Nur bringen mich die Erros leider nicht weiter.
Dankeschön schon mal im Voraus.

change_size(m_data,m_size,fields);

sondern so -->

change_size(&m_data,m_size,fields);

Verbesserungen und Tipps wären aber trotzdem noch erwünscht. (das is ja noch lang nicht fertig is ja nur das Gründgerüst bis jetzt)

Dankeschön schon mal im Voraus.

PS: Is echt n äußerst gutes Tutorial

Mh verstehe ich net, warum nur "T *array"??? Dann hab ich ja nur Zugriff auf den Inhalt von array??? und mit "T **array" hätte ich doch Zugriff über den Zeiger, wie sollte ich den da das reservierte Zeuge deleten wenn es heißen würde "T *array"? Oder?

jo, das haste recht.

Aber ich hab jetzt auch meinen Fehler entdeckt, ich muss bei "T **array" als Argument auch die Afress von dem Zeiger übergeben. Also muss die Stelle hier (vector.hpp\Zeile 75):
Nicht so heißen -->

change_size(m_data,m_size,fields);

sondern so -->

change_size(&m_data,m_size,fields);

stimmt.

dann müßte uch
void size<T>::change_size(T &array,int length_old,int extension)
klappen (mit dem alten aufruf). also array ist eine referenz auf einen zteiger auf T. sieht aber nicht so hübsch in meinen augen aus wie T*.