Speicherverwaltung, Operatorüberladung

Hallo,

malwieder so ne Übungsaufgabe. Ich komme leider nicht weiter. Die stellen an dehnen ich Probleme habe hab ich mit // versehen. Wäre dankbar für eure Hilfe.

#include <iostream>
using namespace std;

class Vektor
{
    private:
        const int dim;                             // soll laut Übung const sein
        int *komponenten;

    public:
        ~Vektor(); 
        Vektor(const Vektor& obj);   
        Vektor& operator+=(const Vektor& other);
        Vektor operator+(const Vektor& other);    
};

Vektor::Vektor(const Vektor& obj) : dim(obj.dim)  // so klappt es   
{  
    // dim = obj.dim;                             // so nicht warum?
    komponenten = new int;
    *komponenten = *(obj.komponenten);
}

Vektor::~Vektor()
{
    delete komponenten;
    komponenten = 0;
}

Vektor::Vektor& operator+=(const Vektor& other)
{
    // Komponentenweise Addition der Operanden falls Dimension gleich sonst
    // Ausgabe einer Fehlermeldung
    // ich bekomme die Implementierung nicht hin :-(
}

Vektor::Vektor operator+(const Vektor& other)
{
   // wie bei operator+=
}

prolog

Hi,

zu problem 1)

dim ist als constant declariert, das bedeutet dass dim nach der initialisierung nicht mehr verändert werden darf. Warum man sie initialisiern kann liegt auf der hand; was nützt einem eine konstante deren wert man nicht festlegen kann.

Normalerweise würde man sowas schreiben:

const int konstante=3;

Das geht bei klassen und structuren nicht, deswegen gibt es etwas dass sich initialisierungsliste nennt. Nur ctors haben initialisierungslisten und in dieser liste kann man zum beispiel konstanten oder andere member initialisieren.

foo::foo() : konstante(3){}

Wie ich bereits sagte darf man eine konstante nach der initialisierung nicht mehr verändern. Die initialisierung erfolgt in der initialisierungsliste oder auch nicht wenn mans einfach weglässt. In diesem fall initialisiert der compiler die variable. Im body des ctors ist das alles schon passiert und deswegen eine zuweisung illegal weil dass ja die bereits initialisierte konstante verändern würde.

zu 2)

Du addierst einfach wie du es bei der vectoren aus der mathematik gewohnt bist und weisst die neuen werte deinem member zu und gibst eine referenz auf das eigene objekt zurück. (stichwort this-zeiger)

zu 3)

Im prinzip wie 2 nur dass du werte nicht zuweisst sondern das ergebnis der addition der componenten einem temporären object vom typ vector zuweisst und dieses zurück gibst als funktionsergebnis.

Wäre das so OK? Wie würde das mit + aussehen?

Vektor::Vektor& operator+=(const Vektor& other)
{
    if(this.dim == other.dim)
    {
       for(int i=0; i<dim; i++)
       {
           *komponenten = *komponenten + *(other.komoponenten);
           komponenten++;
       }
    }

    return *this;
}

komponenten++ ist böse, weil du dadurch den Zeiger in deinem Vektor dauerhaft veränderst. Wenn du es mit einem temporären machst, dürfte es klappen. Vielleicht wäre es auch übersichtlicher, einfach die Index-Schreibweise zu verwenden.
Amsonsten würde ich noch eine Exception werfen, wenn die Dimensionen nicht passen.

Ich sehe grad noch, dass keiner was zum delete gesagt hat. Wenn du ein Array löscht, musst du delete[] verwenden. Aber der Konstruktor legt auch nur ein einzelnes int an. Das soll doch ein Array von ints werden, oder?

groovemaster

Wernus schrieb:

Wäre das so OK?

Zu dem was Optimizer bereits gesagt hat, kommt noch hinzu, dass this ein Zeiger ist. Du musst deshalb '(*this).dim' oder 'this->dim' schreiben. Oder this am besten ganz weglassen.

Wernus schrieb:

Wie würde das mit + aussehen?

Die binären Non-Assignment Operatoren kann man sehr einfach über die Assignment Operatoren implementieren. Das verhindert Code Redundanz und ist deshalb leichter wartbar und weniger fehleranfällig. Sofern nicht direkt vorgeschrieben, wäre es besser, wenn du op+ ausserhalb der Klasse implementierst.

Vektor operator +(const Vektor& lhs, const Vektor& rhs)
{
    Vektor tmp(lhs);
    tmp += rhs;
    return tmp;
}

Hallo,

bei mir ist jetzt irgendwie die totalle Verwirrung ausgebrochen. Bin auch noch eine totaller Neuling. Naja jedenfalls war in der Aufgabenstellung nur folgendes vorgegeben:

class Vector
{
    private:
        const int dim;
        int *komponenten;
    public:
        ...
}

und folgende Deklarationen

Vektor& operator+=(const Vektor& other);
Vektor operator+(const Vektor& other);

Nun geht es nur darum die beiden überladenen Operatoren korrekt zu definieren.
Die überladenen Operatoren sollen eine Komponentenweise Additon der Operanden durchführen. Sind die Dimensionen der Operanden verschieden soll mit einer Fehlermeldung abgebrochen werden.

Könnt ihr mir vielleicht die komplette Implementierung der beiden Funktionen angeben. Ich bekomme es einfach nicht hin

Du solltest es erstmal hinbekommen, im Konstruktor auch wirklich ein Array anzulegen und dieses im Destruktor wieder zu löschen. Vorher hast du gar nichts zum Komponentenweise addieren. Ohne bösartig sein zu wollen, aber ich hoffe, dass dir hier das keiner macht. Du lernst viel mehr, wenn du es von selber hinkriegst.
Was das komponentenweise Addieren dann angeht: Du bist doch mit Arrays einigermaßen vertraut, oder? Du musst doch immer nur die Elemente mit gleichem Index aufaddieren.