Array Operator überladen?

...komplette Frage anzeigen

2 Antworten

Sofern vec als eindimensionale Variable und vec als mehrdimensionale Variable denselben Namen haben, geht das nicht.

Vector2D vec;

Vector2D * vec_array[1];

vec_array[0] = &vec;

// verändert vec

vec_array[0].x = 5;

Vector2D.h:

#ifndef __VECTOR2D_H__
#define __VECTOR2D_H__
#include <stdexcept>
class Vector2D{
protected:
int x,y;
public:
Vector2D();
Vector2D(int x, int y);
void setX(int X);
void setY(int Y);
int getX();
int getY();
int operator[](int i) const;
int& operator[](int i);
};
#endif /*__VECTOR2D_H__*/

Vector2D.cpp:

#include "Vector2D.h"
Vector2D::Vector2D(){
this->x = this->y = 0;
}
Vector2D::Vector2D(int x, int y){
this->x = x;
this->y = y;
}
void Vector2D::setX(int x){
this->x = x;
}
void Vector2D::setY(int y){
this->y = y;
}
int Vector2D::getX(){
return this->x;
}
int Vector2D::getY(){
return this->y;
}
int Vector2D::operator[](int i) const{
switch(i){
case 0: return this->x;
case 1: return this->y;
default: throw std::out_of_range("dimension out of range");
}
}
int& Vector2D::operator[](int i){
switch(i){
case 0: return this->x;
case 1: return this->y;
default: throw std::out_of_range("dimension out of range");
}
}

P.S.: Es gilt im allgemeinen als "unfein" im Bereich OOP ohne Getter/Setter zu arbeiten, wenn es sich vermeiden lässt...

Tuxgamer2 07.07.2017, 12:15

P.S.: Es gilt im allgemeinen als "unfein" im Bereich OOP ohne Getter/Setter zu arbeiten, wenn es sich vermeiden lässt...

Nein, im Bereich OOP ist es genauso unfein mit Getter/Setter zu arbeiten.

Denn das läuft +/- syntaktischen Zucker aufs exakt gleiche wie eine public Variable hinaus.

Ja - in diesem Fall haben wir ein "Storageobjekt", was einfach Zeug speichert. In diesem Fall macht Getter/Setter bzw. public Variable durchaus Sinn. Vector2D wird ja direkt privater Teil eines anderen Objektes sein und damit trotzdem gewrappt und gekapselt.

Und ja: Auch in C++ ist der Syntax "Getter/Setter" dem Syntax "public Variable" überlegen (gibt Sprachen wie C# oder Python, da sehe ich das anders).

Aber wenn ich einen Getter/Setter (anstatt privater Variable) verwende, dann aus einem ziemlich ähnlichen Grund wie dass ich lieber enum anstatt #define NAME=1 vewende.

Aus Objektorientierter Sicht ist beides gleicher Mist und gilt beides zu vermeiden, wenn irgendwie sinnvoll möglich.

2
Isendrak 07.07.2017, 18:02
@Tuxgamer2

Denn das läuft +/- syntaktischen Zucker aufs exakt gleiche wie eine public Variable hinaus.

Nicht unbedingt... Innerhalb einer Setter Methode kann z.B. noch eine Überprüfung/Nachbearbeitung des Wertes durchegeführt werden.

Nehmen wir als Beispiel eine Klasse, die Datums/Uhrzeitangeben beinhalten soll, mit einer public Variable für Minuten, kann der Wert auch einfach mal auf 70 oder ggf. -10 gesetzt werden, mit einem Setter dagegen kann entweder bei einem Wert < 0 bzw. > 59 eine Exception geworfen werden (oder man nimmt als Rückgabewert z.B. bool, true = alles OK, false = Oh, Oh...) oder auch die über-/unterschüssigen Minuten entsprechend mit den Stunden verrechnet werden.

In dem Fall brauch man natürlich auch nen Getter um wieder an die Daten dranzukommen.

Okay, man kann sich zwar den Setter u.u. sparen, indem die Werte einfach dem Konstruktor übergeben werden, aber es gibt Situationen, in denen das etwas unpraktisch wäre...

Ansonsten hast natürlich Recht, wenns ohne Getter/Setter bzw. public Variable geht, dann sollte das auch ohne gemacht werden, aber trotzdem ist falls nötig, das Getter/Setter Prinzip meist vorzuziehen.

0

Was möchtest Du wissen?