Vector-Templateklasse aus C++-Buch

joomoo

Aus einem C++-Buch hab ich folgende Vector-Templateklasse:

template<class T>
class Vector
{
    public:
        Vector(unsigned n=8) : size_(n), data(new T[size]) { }
        Vector(const Vector<T>& v) : size_(v.size), data(new T[size]) {
            copy(v);
        }
        ~Vector() {
            delete [] data;
        }
        Vector<T>& operator=(const Vector<T>&);
        T& operator[](unsigned i) const {
            return data[i];
        }
        unsigned size() { // 18
            return size;
        }
    private:
        T* data;
        unsigned size; // 23
        void copy(const Vector<T>&);
};

Beim compilen werd ich allerdings mit Fehlermeldungen überschüttet! Vor allem diese hier versteh ich nicht:

23 C:\Dev-Cpp\main4.cpp declaration of `unsigned int Vector<T>::size' 
18 C:\Dev-Cpp\main4.cpp conflicts with previous declaration `unsigned int Vector<T>::size()'

Okay, ihr werdet jetzt sagen, dass det gar nicht gut, dass ich das nur abschreibe aus dem Buch und es nicht wirklich verstehe, aber ich möchte es mindestens einmal compiliert bekommen! Und vor allem frage ich mich warum das so in dem Buch steht und nicht geht?!?

mfg.

FireFlow

Eine Methode kann nicht gleich heißen wie ein Atrribut.

Gruß

michba

Du hast in deinem Code sowohl eine Methode size als auch eine Membervariable size, das kann ja nicht gutgehen.
Und da im (copy)Konstruktor eine Variable namens size_ initialisiert wird, gehe ich davon aus, dass du beim Abschreiben aus dem Buch den Underscore bei der Membervariablen vergessen hast.

joomoo

Also das steht in dem Buch wirklich ohne unterstrich drinn, den hatte ich vorher mal hinzugefügt zum testen, hatte mich aber dann entschlossen doch zu fragen.

Okay danke jetzt ist der Fehler schonmal weg:

template<class T>
class Vector
{
    public:
        Vector(unsigned n=8) : size_(n), data(new T[size]) { } // 7
        Vector(const Vector<T>& v) : size_(v.size), data(new T[size]) {
            copy(v);
        }
        ~Vector() {
            delete [] data;
        }
        Vector<T>& operator=(const Vector<T>&);
        T& operator[](unsigned i) const {
            return data[i];
        }
        unsigned size() {
            return size_;
        }
    private:
        T* data;
        unsigned size_;
        void copy(const Vector<T>&);
};

Nun krieg ich allerdings folgenden Fehler, mit dem ich noch weniger anfangen kann:

C:\Dev-Cpp\main4.cpp In constructor `Vector<T>::Vector(unsigned int) [with T = short int]': 
7 C:\Dev-Cpp\main4.cpp size in array new must have integral type 
7 C:\Dev-Cpp\main4.cpp aggregate value used where an integer was expected

Was mit einem intergralen Typ gemeint?

mfg.

finix

joomoo schrieb:

Was mit einem intergralen Typ gemeint?

Änder auch dort size zu size_...
Ein ganzzahliger (=integral) Typ wird für die Arraygröße benötigt, nicht die Adresse einer Methode.

joomoo

Stimmt! Danke finix! Ich Trottel!

Jetzt hab ich alle ersetzt, aber der Code verabschiedet sich mit einem Laufzeitfehler (bzw. das Fenster wird gleich wieder geschlossen).

#include <iostream>

template<class T>
class Vector
{
    public:
        Vector(unsigned n=8) : size_(n), data(new T[size_]) { }
        Vector(const Vector<T>& v) : size_(v.size_), data(new T[size_]) {
            copy(v);
        }
        ~Vector() {
            delete [] data;
        }
        Vector<T>& operator=(const Vector<T>&);
        T& operator[](unsigned i) const {
            return data[i];
        }
        unsigned size() {
            return size_;
        }
    private:
        T* data;
        unsigned size_;
        void copy(const Vector<T>&);
};

template<class T>
Vector<T>& Vector<T>::operator=(const Vector<T>& v) {
    size = v.size;
    data = new T[size];
    copy(v);
    return *this;
}

template<class T>
void Vector<T>::copy(const Vector<T>& v) {
    unsigned min_size = (size_ < v.size_ ? size_ : v.size_);
    for (int i = 0; i < min_size; i++) {
        data[i] = v.data[i];
    }
}

int main()
{
    Vector<short> v;
    v[5] = 127;
    Vector<short> w = v, x(3);
    std::cout << w.size();
    system("PAUSE");
}

Werner Salomon

Das ist ein Fehler, den der Lint sofort finden würde

Die Member sind definiert in der Reihenfolge

private:
        T* data;
        unsigned size_;

also erst data und dann size_
Im Konstruktor steht

public:
        Vector(unsigned n=8) : size_(n), data(new T[size_]) { }

size_ vor data. Dies kümmert aber den Compiler nicht. Die Initialisierung geschieht immer in der Reihenfolge der Definition in der Klasse - also data zuerst. Zu diesem Zeitpunkt steht in size_ alles mögliche drin, aber bestimmt nicht n!

Ändere also die Reihenfolge der Member

private:
        unsigned size_;  // size_ vor data
        T* data;

.. hol' Dir Dein Geld für das Buch zurück. In der Methode

T& operator[](unsigned i) const {
            return data[i];
        }

ist das const falsch und in

unsigned size() {
            return size_;
        }

fehlt das const hinter size()

Gruß
Werner

LordJaxom

Darf ich noch anmerken dass default-int in C++ eigentlich auch nicht erlaubt ist?

joomoo

Vielen Dank für eure Hilfe! Jetzt klappt's:

#include <iostream>

template<class T>
class Vector
{
    public:
        Vector(unsigned int n=8) : size_(n), data(new T[size_]) { }
        Vector(const Vector<T>& v) : size_(v.size_), data(new T[size_]) {
            copy(v);
        }
        ~Vector() {
            delete [] data;
        }
        Vector<T>& operator=(const Vector<T>&);
        T& operator[](unsigned int i) {
            return data[i];
        }
        unsigned int size() const {
            return size_;
        }
    private:
        unsigned int size_;
        T* data;
        void copy(const Vector<T>&);
};

template<class T>
Vector<T>& Vector<T>::operator=(const Vector<T>& v) {
    size = v.size;
    data = new T[size];
    copy(v);
    return *this;
}

template<class T>
void Vector<T>::copy(const Vector<T>& v) {
    unsigned int min_size = (size_ < v.size_ ? size_ : v.size_);
    for (int i = 0; i < min_size; i++) {
        data[i] = v.data[i];
    }
}

int main()
{
    Vector<short> v;
    v[5] = 127;
    Vector<short> w = v, x(3);
    std::cout << w.size() << std::endl;
    std::cout << x.size() << std::endl;
    std::cout << v[5] << std::endl;
    system("PAUSE");
}

Jaaaa, ich weiß, dass das Buch nicht so gut ist, aber es war runtergesetzt. Immerhin lerne ich was dabei

mfg.

edit: ist übrigens dieses buch: http://www.amazon.de/exec/obidos/ASIN/3826609107/qid=1143892707/sr=8-2/ref=sr_8_xs_ap_i2_xgl/303-3420400-9284243

DrOetker

warez666 schrieb:

Das Buch schneidet einige wichtige Bereiche der C++-Programmierung an und steckt auch voller Übungsaufgaben, die durch das gesamte Buch begleiten, was diesem Werk auch hoch anzurechnen ist. Die Fehler, die in diesem Buch stecken, sind jedoch enorm. Wie bereits erwähnt: Falsche Fragen zu den Kapiteln, falsche Antworten, fehlerhafte Quellcodes und und und ... meiner Meinung nach, ist es in keinem Fall zu empfehlen. Da sollte man lieber ein paar Euro mehr investieren und sich ein ordentliches Buch kaufen.

*g*

hol dir ein anderes...