3. Telefonbuchprogramm

Telefonbuchprogramm

  • S

    So ich mach grad das Projekt aus dem Volkard Tutorial durch (Telefonbuchprogramm). Eigentlich funktioniert alles, aber ab dem Moment, wenn ich dem vector (selber gebastelt NUR ZUR ÜBUNG!!!)einen Wert zuweisen möchte dann klappt es nicht mehr und es kommen ganz viele Errors.
    Ich glaub das liegt irgendwie an meinen "templats" und besonders mit dem "template" von der Klasse "size". Und es könnte vll. auch an der Vererbung liegen, die Klasse vector erbt die Methoden von der Klasse size. Is das noch ganz koscher? Oder war des nä blöde Idee?
    So gesehen sind die ja auch nicht miteinander verwandt, aber es gibt ja auch abstrakte Datentypen, also kann man das auch vererben??
    Also irgendwie blick ich des net. Ich glaub da is sicher n Fehler mit dem template von der Klasse size bei dem übergang mit der vererbung... aber so genau weiß ichs irgendwie odch nicht!?
    Hier einfach mal der Code+Erros wahrschenilich bin ich einfach schon zu müde 🙂
    Wer noch wach ist und Lust hat --> HAU REIN 😃

    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.

    0
  • V

    mir scheint, change_size(T &array,... sollte change_size(T *array,... heißen in size.hpp.

    0
  • S

    Ah Hallöchen 😃
    Dann müsste das Argument "array" aber ein Doppelzeiger sein oder? Also "T **array".
    Ich hab die Methode "change_size" jetzt mal umgeschrieben, meiner Meinung nach müsste die dann jetzt so heißen.

    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.

    0
  • V

    nö, nur T* array.

    0
  • S

    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?
    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);

    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 👍 👍 👍

    0
  • V

    und bei
    for (int i=0;i<(length_old+extension);i++)
    {
    array[i]=cache[i];
    }
    haste noch nen abstorz. das feld namens cache ist gar nicht so groß, daß du bis da hinten lesen dürftest.

    0
  • V

    Stromberg schrieb:

    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    *.

    0
Anmelden zum Antworten