[C++/CLI] Juiste aanpak om met Classes te programmeren

[mrFoce]

Ik ben redelijk nieuw met c++, het hele OOP gebeuren etc.. Op school wel kennis gemaakt met Java, en toen altijd 'getters' en 'setters' gebruikt. Nu ben ik in c++ tegen iets aangelopen, en dat is dat ik geen 'getters' en 'setters' hoef te gebruiken, maar dat het wel mogelijk is om ze te gebruiken.

Mijn vraag: Wat is nu de juiste aanpak, en waarom? Gebruik ik classes op de juiste manier?

(denk dat dit topic wel nuttig is voor andere startende mensen zoals ik)

Aanroep methodes:

code:

[b]Methode 1:[/b]
testClass^ tC = gcnew testClass;
MessageBox::Show ( " Constructor value ; \n\n" + tC->blaat1.ToString() );
tC->setBlaat1( 50 ); MessageBox::Show ( " tC->setBlaat1( 50 ); \n\n" + tC->getBlaat1().ToString() );
tC->setBlaat1( 25 ); MessageBox::Show ( " tC->setBlaat1( 25 ); \n\n" + tC->getBlaat1().ToString() );
tC->doubleIt(); MessageBox::Show ( " tC->doubleIt(); \n\n" + tC->doubleIt().ToString() );

[b]Methode 2:[/b]
testClass^ tC = gcnew testClass;
MessageBox::Show ( " Constructor value ; \n\n" + tC->blaat1.ToString() );
tC->blaat1 = 50; MessageBox::Show ( " tC->blaat1 = 50; \n\n" + tC->blaat1.ToString() );
tC->blaat1 = 25; MessageBox::Show ( " tC->blaat1 = 25; \n\n" + tC->blaat1.ToString() );
tC->doubleIt(); MessageBox::Show ( " tC->doubleIt(); \n\n" + tC->doubleIt().ToString() );

Class testClass.h:

code:

ref class testClass
{
public:
    int blaat1;
    int blaat2;

    int setBlaat1( int blaat1);
    int getBlaat1();
    int doubleIt ();


    testClass(void);

};

Class testClass.cpp:

code:

#include "StdAfx.h"
#include "testClass.h"


testClass::testClass(void)
{
    this->blaat1 = 100;
}


int testClass::setBlaat1(int blaat1)
{
    return this->blaat1 = blaat1;
}

int testClass::getBlaat1()
{
    return this->blaat1;
}

int testClass::doubleIt()
{
    return ( this->blaat1 * 2 );
}

Dit topic lijkt een beetje op deze topic -> [rml][ JAVA] Bang voor verkeerde aanpak[/rml]
echter gaat deze meer over Java

[ Voor 8% gewijzigd door mrFoce op 10-03-2006 14:08 ]

[matthijsln]

In Java ben je anders ook niet verplicht om getters setters te gebruiken, dus wat dit betreft is er niet zoveel verschil.

[ Voor 19% gewijzigd door matthijsln op 10-03-2006 14:43 ]

[.oisyn]

De nieuwe .Net syntax extensions voor C++ zijn omgedoopt naar een officiele nieuwe taal. Deze taal heet C++/CLI, vandaar dat ik je topictitel dus gewijzigd heb.

Wat betreft die getters/setters: dat hangt natuurlijk maar net van je doel af . Als je getters/setters maakt is het iig nogal onzinnig om je variabelen ook public te maken, aangezien het dan niet de bedoeling is dat mensen er van buitenaf bij kunnen. Het gebruik van getters/setters is wel aan te raden, tenzij je class echt een datatype is (zoals bijvoorbeeld een complex getal of een 3d vector), maar dan doe je er ook beter aan die classes te definieren als value classes ipv ref classes.

[Verwijderd]

Volgens mij kun je in deze situatie het beste getters/setters gebruiken, want die encapsuleren de interne variabele (blaat1). Die laatste kun je dan beter private maken, zodat toegang via de get/set methoden moet lopen (waar je dan evt. field BL kwijt kan).

In .NET heb je ook nog properties, waarvoor je een set en/of get methode kunt specificeren. Dat werkt nog wat fijner, maar ik weet niet zeker of zoiets ook in C++ voorhanden is.

[ Voor 6% gewijzigd door Verwijderd op 10-03-2006 15:08 ]

[Verwijderd]

code:

ref class testClass
{
private: // evt protected
    int blaat1;
    int blaat2;

public:
    int setBlaat1( int blaat1);
    int setBlaat2( int blaat2);

    int getBlaat1();
    int getBlaat2();
    int doubleIt ();

    testClass(void);
};

[.oisyn]

Verwijderd schreef op vrijdag 10 maart 2006 @ 15:07:
In .NET heb je ook nog properties, waarvoor je een set en/of get methode kunt specificeren. Dat werkt nog wat fijner, maar ik weet niet zeker of zoiets ook in C++ voorhanden is.

C++ niet, maar C++/CLI wel.

C++:

ref struct S
{
    property int foo
    {
        int get();
        void set(int i);
    };

private:
    int m_int;
};

int S::foo::get()
{
    return m_int;
}

void S::foo::set(int i)
{
    m_int = i;
}

[ATS]

Het is een kwestie van stijl. Zelf gebruik ik meer deze stijl:

C++:

class testClass
{
public:
    testClass();
    
    int blaat() const;
    int setBlaat(const int& theValue);

private:
    int m_blaat;
}

Overigens kan je met bijvoorbeeld Qt ook properties maken, en ze zitten vast ook wel in andere toolkits.

[ Voor 22% gewijzigd door ATS op 10-03-2006 16:10 ]

[.oisyn]

De reden dat het met Qt kan is omdat dat ook geen C++ is maar een extensie van C++. Een normale toolkit past een taal niet aan, Qt is wat dat betreft een uitzondering (en nogal obsolete imho, maar die discussie is al eerder gevoerd). Verschillende C++ compilers ondersteunen properties trouwens ook wel op een of andere manier (Borland C++ en MSVC++ iig), maar ze zijn geen van allen standaard of portable, dus kun je ze maar beter niet gebruiken.

Maar goed, het gaat hier niet om C++ maar om C++/CLI, en die heeft ze gewoon

[ Voor 24% gewijzigd door .oisyn op 10-03-2006 16:15 ]

[ATS]

Off topic:
Qt obsolete? Kan je me verwijzen naar die discussie? Ik ben erg benieuwd waarom dat het geval zou zijn namelijk. Zelf ben ik er ERG over te spreken...

[kingmuze]

Het nadeel van getters en setters is dat het *iets* meer werk kost. Het voordeel is dat wanneer je extra functionaliteit wil toevoegen aan een get/set methode, dit makkelijk kan.

[.oisyn]

ATS schreef op zaterdag 11 maart 2006 @ 20:15:
Off topic:
Qt obsolete? Kan je me verwijzen naar die discussie? Ik ben erg benieuwd waarom dat het geval zou zijn namelijk. Zelf ben ik er ERG over te spreken...

offtopic:
Ik zeg niet dat Qt obsolete is, ik zeg dat de preprocessor die je voor Qt nodig hebt obsolete is, omdat het elementen toevoegt die prima met standaard C++ op te lossen zijn en elke moderne compiler die features ook wel ondersteunt. Het gaat hier dan met name om de signals+slots. Die discussie begon hier.