Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

C++ Attribute der abgeleiteten Klasse verwenden

Werbeanzeige

Koschi

Alter Hase

Beiträge: 657

  • Private Nachricht senden

31

14.07.2016, 18:54

Wie schaut den aktuell der Code aus?
Wer aufhört besser werden zu wollen hört auf gut zu sein!

aktuelles Projekt:Rickety Racquet

MitgliedXYZ

Alter Hase

  • »MitgliedXYZ« ist der Autor dieses Themas

Beiträge: 1 369

Wohnort: Bayern

  • Private Nachricht senden

32

14.07.2016, 19:01

Der UserInterface Teil sieht so aus:

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

class UiControl
{
protected:
    UiControl()
    {
        //The constructor UiControl is private, only objects of subclasses can be created
    }

public:
    int x;
    int y;
    
    int width;
    int height;

    enum TypeTag { BUTTON, TEXT_FIELD };
    TypeTag typeTag;

    virtual void draw()
    {
        
    }
};

class Button : public UiControl
{
public:
    string caption;

    ofColor backgroundColor;
    ofColor foregroundColor;

    Button(int x, int y, int width = 200, int height = 50, string caption = "")
    {
        this->x = x;
        this->y = y;
        this->width = width;
        this->height = height;
        this->caption = caption;

        this->backgroundColor = blue;
        this->foregroundColor = grey;

        this->typeTag = BUTTON;
    }

    void draw()
    {
        ofSetColor(this->backgroundColor);
        ofRect(this->x, this->y, this->width, this->height);
    }
};

class UiTools
{
public:
    std::vector<UiControl*> uiControls;

    UiTools(int screenWidth, int screenHeight)
    {
        windowResized(screenWidth, screenHeight);

        Button* button = new Button(10, 10);
        (*button).caption = "Text";

        uiControls.insert(uiControls.begin(), button);
    }

}


Die unique_ptr habe ich noch nicht eingebaut und die Initialisierungs Listen will ich noch verwenden.

Koschi

Alter Hase

Beiträge: 657

  • Private Nachricht senden

33

14.07.2016, 19:21

Datenkapselung sieht anders aus :P
Die Klassen sollten keine Public members haben.
Minimum sollten die member protected sein eher private und eine get-Methode anbieten.

Nach wie vor nutzt du den Konstruktor der Basisklasse nicht, eventuell weil du dann Initialisierungslisten nutzen must (fand die früher auch gewöhnungs bedürftig).

Hier mal kleines Bsp.

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Basis
{
private:
    int m_x;
public:
    Basis(int x) :
        m_x(x)
    { }
};

class Child : public Basis
{
public:
    Child(int x) :
        Basis(x)
    { }
};


Auf diese Weise muss die Childklasse auf die member der Basisklasse nicht mal zwingend zugreifen. Wenn doch nötig kann die Basisklasse get/set Methoden anbieten.

Edit: dein letzten Satz habe ich jetzt erstgelesen.
Wer aufhört besser werden zu wollen hört auf gut zu sein!

aktuelles Projekt:Rickety Racquet

BlueCobold

Community-Fossil

Beiträge: 10 738

Beruf: Teamleiter Mobile Applikationen & Senior Software Engineer

  • Private Nachricht senden

34

14.07.2016, 19:23

Zitat von »Koschi«

und eine get-Methode anbieten
Oder auch nicht...
Teamleiter von Rickety Racquet (ehemals das "Foren-Projekt") und von Marble Theory

Willkommen auf SPPRO, auch dir wird man zu Unity oder zur Unreal-Engine raten, ganz bestimmt.[/Sarkasmus]

Koschi

Alter Hase

Beiträge: 657

  • Private Nachricht senden

35

14.07.2016, 19:25

Zitat von »BlueCobold«

Zitat von »Koschi«

und eine get-Methode anbieten
Oder auch nicht...

Habe es weiter unten ja noch relativiert, wenn nötig ... ;)
Wer aufhört besser werden zu wollen hört auf gut zu sein!

aktuelles Projekt:Rickety Racquet

MitgliedXYZ

Alter Hase

  • »MitgliedXYZ« ist der Autor dieses Themas

Beiträge: 1 369

Wohnort: Bayern

  • Private Nachricht senden

36

14.07.2016, 20:28

Verwendest du Initialisierungslisten, um die Laufzeit zu reduzieren, damit die Attribute direkt mit dem richtigen Wert initialisiert werden und nicht weil du es so lesbarer findest?

Nur dann finde ich es komisch, für Attribute wie x und y Koordinaten Setter und evtl. Getter einzubauen. So muss doch noch ein Element mehr auf dem Stack gelegt werden, was das Program wieder langsamer macht.
Das Argument für Getter und Setter ist doch, dass ich so merke, wenn etwas verändert wird und es falls nötig auf verschiedene Bedingungen überprüfen kann. Bei so etwas wie Koordinaten, Abmessungen und Farben fällt mir allerdings kein Anwendungsszenario dafür ein.

Koschi

Alter Hase

Beiträge: 657

  • Private Nachricht senden

37

14.07.2016, 20:51

Zitat von »MitgliedXYZ«

Verwendest du Initialisierungslisten, um die Laufzeit zu reduzieren, damit die Attribute direkt mit dem richtigen Wert initialisiert werden und nicht weil du es so lesbarer findest?

Nein weil mein obiges Beispiel nicht anders funktioniert, wenn man sich an Sachen wie Datenkapselung hält und Konstruktoren nutz. Wie und ob sich das überhaupt bei der Geschwindigkeit bemerkbar macht weiß ich nicht.

Zitat von »MitgliedXYZ«

Nur dann finde ich es komisch, für Attribute wie x und y Koordinaten Setter und evtl. Getter einzubauen.

Bitte nicht vergessen, dass das nur ein minimal Beispiel war. Koordinaten x, y würden in einem Struct landen. Dafür würde ich dann eine Get/Set-Methode machen (wenn nötig ;) ).

Zitat von »MitgliedXYZ«

So muss doch noch ein Element mehr auf dem Stack gelegt werden, was das Program wieder langsamer macht.

Was genau meinst du?
Wer aufhört besser werden zu wollen hört auf gut zu sein!

aktuelles Projekt:Rickety Racquet

MitgliedXYZ

Alter Hase

  • »MitgliedXYZ« ist der Autor dieses Themas

Beiträge: 1 369

Wohnort: Bayern

  • Private Nachricht senden

38

16.07.2016, 15:20

Zitat von »Koschi«

Zitat von »MitgliedXYZ«
So muss doch noch ein Element mehr auf dem Stack gelegt werden, was das Program wieder langsamer macht.

Was genau meinst du?

Also ich meinte, dass button.x = 5; eine kürzere Ausführungszeit benötigt, als button.setPosX (5); da so eine Methode auf dem Call Stack abgelegt wird und erst danach die Variable verändert wird. Kann natürlich sein, dass der Geschwindigkeits Unterschied gering ist, bzw. vom Compiler so optimiert wird, dass die Methode in eine Inline-Methode umgewandelt wird, also beide Varianten den selben Code nach dem Compilieren produzieren.

Den Code habe ich mal verbessert. Mit den Struct für die Position und Größe wird die Benutzung aber umständlicher.
Einen neuen Button konnte ich vorher mit einer Zeile erstellen.

C-/C++-Quelltext

 
1

Button* button = new Button(10, 10, 200, 50);

Mit dem neuen Code benötige ich drei Zeilen, kann man das noch verbessern?

C-/C++-Quelltext

 
1
2
3

Position position = { 10, 10 };
Size size = { 200, 50 };
Button* button = new Button(position, size);


C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

struct Position
{
    int x;
    int y;
};

struct Size
{
    int width;
    int height;
};

class UiControl
{
protected:
    Position position;
    Size size;

    UiControl(Position position, Size size)
    {
        this->position = position;
        this->size = size;
    }

    void setPosition(Position position)
    {
        this->position = position;
    }

    Position getPosition()
    {
        return position;
    }

    void setSize(Size size)
    {
        this->size = size;
    }

    Size getSize()
    {
        return size;
    }

public:
    virtual void draw();
};

class Button : public UiControl
{
public:
    string caption;

    ofColor backgroundColor;
    ofColor foregroundColor;

    Button(Position position, Size size, string caption = "") : UiControl(position, size)
    {
        this->caption = caption;

        this->backgroundColor = blue;
        this->foregroundColor = grey;
    }

    void draw()
    {
        ofSetColor(this->backgroundColor);
        ofRect(position.x, position.y, size.width, size.height);
    }
};

Schorsch

Supermoderator

Beiträge: 5 145

Wohnort: Wickede

Beruf: Softwareentwickler

  • Private Nachricht senden

39

16.07.2016, 15:42

Zitat von »MitgliedXYZ«

Also ich meinte, dass button.x = 5; eine kürzere Ausführungszeit benötigt, als button.setPosX (5); da so eine Methode auf dem Call Stack abgelegt wird und erst danach die Variable verändert wird. Kann natürlich sein, dass der Geschwindigkeits Unterschied gering ist, bzw. vom Compiler so optimiert wird, dass die Methode in eine Inline-Methode umgewandelt wird, also beide Varianten den selben Code nach dem Compilieren produzieren.

Das riecht nach premature optimization und wie du schon richtig festgestellt hast wird das unter Umständen eh von Compiler weg optimiert. Über solche Dinge würde ich mir keine Gedanken machen. Wenn du mit einem Profiler guckst und dabei tatsächlich feststellst dass du da optimieren solltest, dann gern. Aber das wird mit ziemlicher Wahrscheinlichkeit nicht eintreten.
„Es ist doch so. Zwei und zwei macht irgendwas, und vier und vier macht irgendwas. Leider nicht dasselbe, dann wär's leicht.
Das ist aber auch schon höhere Mathematik.“

Koschi

Alter Hase

Beiträge: 657

  • Private Nachricht senden

40

16.07.2016, 18:20

Zitat von »MitgliedXYZ«

Also ich meinte, dass button.x = 5; eine kürzere Ausführungszeit benötigt, als button.setPosX (5); da so eine Methode auf dem Call Stack abgelegt wird und erst danach die Variable verändert wird. Kann natürlich sein, dass der Geschwindigkeits Unterschied gering ist, bzw. vom Compiler so optimiert wird, dass die Methode in eine Inline-Methode umgewandelt wird, also beide Varianten den selben Code nach dem Compilieren produzieren.

Du hast dir ja schon selber die antwort gegeben, das Letztlich entscheidend ist wie der compiler das ganze umsetzte.

Zitat von »MitgliedXYZ«

Den Code habe ich mal verbessert. Mit den Struct für die Position und Größe wird die Benutzung aber umständlicher.

Ich finde, dass die Anzahl der Codezeilen nichts über die Umständlichkeit aussagt. Ich würde sagen der Code ist jetzt nicht Umständlicher sondern lesbarer!

Ein einzeiler lässt sich immernoch draus machen.

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

struct Position
{
    int x;
    int y;
    Position(int _x = 0, int _y = 0) :
        x(_x),
        y(_y)
    { }
};

struct Size
{
    int width;
    int height;
    Size(int _width = 0, int _height = 0) :
        width(_width),
        height(_height)
    { }
};

Button* button = new Button(Position(10, 10), Size(200, 50));


Nach wievor sind in deiner Klasse Button die Member public.
Wer aufhört besser werden zu wollen hört auf gut zu sein!

aktuelles Projekt:Rickety Racquet

Werbeanzeige

Ähnliche Themen