constructors, lid- en klasse functies

[BugMenOT2]

Hallo,

Je kan waardes van leden naar het scherm schrijven mbv lidfunctie

bv:

class cordinaat
{
 private:
            int x;
            int y;

 public:
           // constructor implementatie binnen de klasse
           cordinaat(int ix, int iy) : x(ix), y(iy)
           {
           }
           //2e constructor implementatie binnen de klasse maar,
           // deze variabelen worden auto 0 als er geen expliciete initialisatie is bij de 
          //declaratie
           cordinaat() : x(0), y(0)
           {
           }

           // prototype lidfunctie
           void functie();
};

void cordinaat::functie()
{
 cout << "<" << x << "," << y << ">";
}

int main()
{
 cordinaat c1(25,50);
 cordinaat c2(35,70);

 c1.functie();
 c2.functie();
}

maar ik heb gelezen dat de tijd die nodig is voor de oproep en de terugkeer van een functie dat je die kan elimineren en dat dit zeker nodig is voor kleine klassefuncties.

bv:

#include <iostream>
using namespace std;

class cordinaat
{
private:
int x;
int y;

public:
// constructor implementatie binnen de klasse
cordinaat(int ix, int iy) : x(ix), y(iy)
{
}
//2e constructor implementatie binnen de klasse maar,
// deze variabelen worden auto 0 als er geen expliciete initialisatie is bij de
//declaratie
cordinaat() : x(0), y(0)
{
}

// prototype lidfunctie
void functie();
int haalx();
int haaly();
};

void cordinaat::functie()
{
cout << "<" << x << "," << y << ">";
}

int cordinaat::haalx()
{
return (x);
}

int cordinaat::haaly()
{
return (y);
}

int main()
{

cordinaat c1(25,50);
cordinaat c2(35,70);

c1.functie();
c2.functie();

cordinaat cc(45,56);
cout << "\ntijd eliminatie oproep en terugkeer functie";
cout << "<" << cc.haalx() << "," << cc.haaly() << ">";
}

maarik begrijp het verschil niet goed.
Zou iemand me dit kunnen uitleggen aub ?

groetjes,
Benny

 

[CoD_NL]

Zal ik net zo'n duidelijk antwoord geven als jouw vraag is ?
(code zou ik sowieso tussen de code-tags zetten, dat maakt het al een stuk duidelijker)

 

[CoD_NL]

't Zal in jouw voorbeeld waarschijnlijk weinig uitmaken. Je zou het kunnen controleren door de verstreken tijd weer te geven.

 

[Murdocki]

dat je op deze manier de aanroeptijd verkort lijkt me de grootste onzin, wat je nu doet is je code onoverzichtelijker maken, wat jij bedoelt is denk ik om met pointers te werken.
je kunt naar iedere variabele een pointer geven.
stel je hebt een tekst van 20 tekens, dit is dan 20 byte. een pointer is altijd 4 byte.

als je nu een pointer doorgeeft dan hoef je niet een var van 20 byte te kopieren maar gewoon eentje van 4 aanmaken en deze laten wijzen naar die 20.

in andere woorden:

void printtext( char[20] x );//bij aanroep word er een var van 20 bytes aangemaakt en gecopieerd
void printtext( char* x );//by aanroep word er een var van 4 byte aangemaakt.

dit heeft natuurlijk gevolgen voor de aanroep:
char[20] mijntext = "lange tekst";
printtext( mijntext );//de 1e optie
printtext( &mijntext );//de 2e optie & staat voor "het beginpunt van..."

printtext( char[20] x )
{
cout << x;
}

of 

printtext( char* x )
{
cout << *x;
}

zoek maar eens wat op over pointers dan zal het duidelijker worden

 

[BugMenOT2]

Bedankt dat je er me opgewezen hebt dat mijn voorbeeld niets uitmaakte ik had hem ook ergens gelezen begreep de code wel maar snapte het nut niet van die tijdeliminatie maar geluk breng jij me dan wel een juist antwoord

groetjes

 

[Murdocki]

dus maakt het nu wel of niet uit of je de impl/decl apart doet of gescheiden?

 

[BugMenOT2]

(apart, gescheiden) betekent dit niet hetzelfde ?

 

[Johantrax]

dus maakt het nu wel of niet uit of je de impl/decl apart doet of gescheiden?

Of je direct een implementatie schrijft of eerst een declaratie en dan een implementie maakt vandaag de dag niet zoveel meer uit. De meeste mensen compileren toch met het standaard-commando van gcc/g++, wat een hele hoop code-optimalisaties in zich draagt...

--Johan

 

[Murdocki]

(apart, gescheiden) betekent dit niet hetzelfde ?

ya k was moe

@johantrax
dus het maakte wel degelijk uit vroeger? hmm k ga even opzoeken waarom want dan begrijp ik een deeltje van de compiler dus niet blijkbaar

 

[bzub]

maar ik heb gelezen dat de tijd die nodig is voor de oproep en de terugkeer van een functie dat je die kan elimineren en dat dit zeker nodig is voor kleine klassefuncties.

Volgens mij heb je iets verkeerd gelezen en bedoelden ze dat je kleine functies ook inline kunt zetten.
Wanneer er in een programmeertaal een functie wordt aangeroepen dan moeten alle waardens ( o.a. variabelen ) waarmee het programma aan het werken was eerst op een stack geplaatst worden. Daarna wordt de functie aangeroepen & uitgevoerd. Tenslotten moet alles terug van de stack gehaald worden. Dit kost tijd.

Voor een gewone return waarden kan je evengoed dit doen ( toegepast op jouw voorbeeld )

/* header file */
include <iostream>
using namespace std;

class cordinaat
{
private:
int x;
int y;

public:
// constructor implementatie binnen de klasse
cordinaat(int ix, int iy) : x(ix), y(iy)
{
}
//2e constructor implementatie binnen de klasse maar,
// deze variabelen worden auto 0 als er geen expliciete initialisatie is bij de
//declaratie
cordinaat() : x(0), y(0)
{
}

// prototype lidfunctie
void functie();
[COLOR="Navy"]int haalx() // dit is geen prototype maar de volledige functie
{
return x;
}

int haaly()  // dit is geen prototype maar de volledige functie
{
return y;
}
}; // einde klasse[/COLOR]

/* cpp file */
void cordinaat::functie()
{
cout << "<" << x << "," << y << ">";
}

/* main cpp file */
int main()
{

cordinaat c1(25,50);
cordinaat c2(35,70);

c1.functie();
c2.functie();

cordinaat cc(45,56);
cout << "\ntijd eliminatie oproep en terugkeer functie";
cout << "<" << cc.haalx() << "," << cc.haaly() << ">";
}

Wat er hier gebeurd is dat je de compiler vraagt om de functie die je in de klasse zelf geimplementeerd hebt "inline" te plaatsen.
Hierdoor wordt er geen functieaanroep gezet in de executable op de plaats waar je hem gezet hebt in de source. In de plaats hiervaan zet de compiler de volledige code op deze plaats. Dit zorgt voor een iets grotere ( reden waarom je dit enkel met kleine functies moet doen ) maar tevens voor een sneller executable.

een opmerking hierbij is dat je enkel "vraagt" aan de compiler om deze functie inline te zetten. De compiler zal zelf beslissen of hij deze vraag inwilligt of niet. Een for-lus zal bijvoorbeeld zelden inline gezet worden door de compiler.

btw: De inline methode die ik gebruikte heet impliciete methode, je kan ook expliciet werken met het "inline" keyword.

Hopelijk was het duidelijk genoeg?

 

[BugMenOT2]

Volgens mij heb je iets verkeerd gelezen en bedoelden ze dat je kleine functies ook inline kunt zetten.
Wanneer er in een programmeertaal een functie wordt aangeroepen dan moeten alle waardens ( o.a. variabelen ) waarmee het programma aan het werken was eerst op een stack geplaatst worden. Daarna wordt de functie aangeroepen & uitgevoerd. Tenslotten moet alles terug van de stack gehaald worden. Dit kost tijd.

Voor een gewone return waarden kan je evengoed dit doen ( toegepast op jouw voorbeeld )

/* header file */
include <iostream>
using namespace std;

class cordinaat
{
private:
int x;
int y;

public:
// constructor implementatie binnen de klasse
cordinaat(int ix, int iy) : x(ix), y(iy)
{
}
//2e constructor implementatie binnen de klasse maar,
// deze variabelen worden auto 0 als er geen expliciete initialisatie is bij de
//declaratie
cordinaat() : x(0), y(0)
{
}

// prototype lidfunctie
void functie();
[COLOR="Navy"]int haalx() // dit is geen prototype maar de volledige functie
{
return x;
}

int haaly()  // dit is geen prototype maar de volledige functie
{
return y;
}
}; // einde klasse[/COLOR]

/* cpp file */
void cordinaat::functie()
{
cout << "<" << x << "," << y << ">";
}

/* main cpp file */
int main()
{

cordinaat c1(25,50);
cordinaat c2(35,70);

c1.functie();
c2.functie();

cordinaat cc(45,56);
cout << "\ntijd eliminatie oproep en terugkeer functie";
cout << "<" << cc.haalx() << "," << cc.haaly() << ">";
}

Wat er hier gebeurd is dat je de compiler vraagt om de functie die je in de klasse zelf geimplementeerd hebt "inline" te plaatsen.
Hierdoor wordt er geen functieaanroep gezet in de executable op de plaats waar je hem gezet hebt in de source. In de plaats hiervaan zet de compiler de volledige code op deze plaats. Dit zorgt voor een iets grotere ( reden waarom je dit enkel met kleine functies moet doen ) maar tevens voor een sneller executable.

een opmerking hierbij is dat je enkel "vraagt" aan de compiler om deze functie inline te zetten. De compiler zal zelf beslissen of hij deze vraag inwilligt of niet. Een for-lus zal bijvoorbeeld zelden inline gezet worden door de compiler.

btw: De inline methode die ik gebruikte heet impliciete methode, je kan ook expliciet werken met het "inline" keyword.

Hopelijk was het duidelijk genoeg?

Bedankt Bzub