Const-Correctness?

[DEvent]

Hallo
wer C++ programmiert kennt sicherlich die Möglichkeit Const-Methoden zu schreiben, damit man von dem Compiler eine Const-Correctness garantiert bekommt.

class Point 
{ 
    int x; 
    int y; 
  public: 
    void setX(int x_)  { x = x_; } 
    void setY(int y_)  { y = y_; } 
    int getX() const   { return x; } 
    int getY() const   { return y; } 
}; 

void manipulatePoints(std::vector<Point>& pl) 
{ 
  pl.at(0).setX(5);  // das ist ok 
} 

void usePoints(const std::vector<Point>& pl) 
{ 
  pl.at(0).setX(5);  // hier meckert schon der Compiler 
}

In Java müsste man dafür eine Immutable und eine mutable-Version der Klasse schreiben:

interface PointInterface 
{ 
    int getX(); 
    int getY(); 
} 

final class Point implements PointInterface 
{ 
    private final x; 
    private final y; 
    public Point(int x, int y); 
    int getX() { return x; } 
    int getY() { return y; } 
} 

class MutablePoint implements PointInterface 
{ 
    private x; 
    private y; 
    public MutablePoint(int x, int y); 
    public MutablePoint(PointInterface point) { x = point.getX(); y = point.getY(); } 
    int getX() { return x; } 
    int getY() { return y; } 
    void setX(int x); 
    void setY(int y); 
} 

//... da PointInterface nur getter hat, ist es const-correct 
PointInterface point = new Point(10, 10); 

//... nun hat man eine Kopie von point, die man ändern kann 
m_point = new MutablePoint(point); 

//... immer noch const-correct, man kann aber explizit casten, um setter zu benutzen 
PointInterface point = new MutablePoint(10, 10);

Wie seht ihr das? Ist das ein fehlendes Feature von Java oder sind const-Methoden eher überflüssig? Passen const-Methoden nicht in das Java-Konzept?

Also ich finde const-Methoden eigentlich überflüssig, da ich sie in Java bis jetzt nicht vermisst habe, obwohl ich früher mit C++ programmiert habe. Aber mit const-Methoden wird schonmal beim kompilieren eine Fehlerquelle ausgeschlossen, was eigentlich immer gut ist.

 

[Roar]

frag doch mal bei c++.de :autsch: :roll:

 

[DEvent]

frag doch mal bei c++.de :autsch: :roll:

Ist ja grade dort eine Diskussion am laufen, ich wollte aber gerne wissen was Javaisten davon halten.

 

[Leroy42]

ich wollte aber gerne wissen was Javaisten davon halten.

Ich bin zwar kein Javaist (eher Javaner ) aber ich gebe mal meinen Senf dazu.

Seit der Umstellung auf Java habe ich das fehlende Konzept der const-correctness
anfangs schmerzlich vermißt, da ich hiervon in C++ (nicht gerade zur Freude
meiner Coder-Kollegen ) reichlich Gebrauch gemacht habe.

Allerdings muß ich zugeben, daß ich es in Java bisher nicht wirklich
gebraucht habe.

 

[Yzebär]

Wo ist denn der Unterschied von const (C++) zu final (Java)? (bei Methodenspezifikationen)

 

[SlaterB]

mit final kann man nur dafür sorgen,
dass der lokalen Variablen, die den Parameter darstellt, kein neues Objekt zugewiesen wird,
das Objekt selber darf verändert werden

 

[Yzebär]

mit final kann man nur dafür sorgen,
dass der lokalen Variablen, die den Parameter darstellt, kein neues Objekt zugewiesen wird,
das Objekt selber darf verändert werden

Meine Frage bezog sich auf final deklarierte Methoden... ich ließ mich leider vom Wort "const-Methoden" des OPs irreführen, er meinte aber eigentlich const-Parameter...

 

[DEvent]

mit final kann man nur dafür sorgen,
dass der lokalen Variablen, die den Parameter darstellt, kein neues Objekt zugewiesen wird,
das Objekt selber darf verändert werden

Meine Frage bezog sich auf final deklarierte Methoden... ich ließ mich leider vom Wort "const-Methoden" des OPs irreführen, er meinte aber eigentlich const-Parameter...

finale Methoden können von abgeleiteten Klassen nicht überschrieben werden. Und ich meine "const-Methoden".

class Foo
{
    // eine Methode, die eine kostante Referenz auf ein Int zurückgibt
    [b]const[/b] int& methodeA();

    // eine const-Methode
    int& methodeA() [b]const[/b];
}

 

[merlin2]

b-Tags funktionieren nicht innerhalb von Codetags - versuch das mal zu kompostieren!