rare error

[pinda kaas]

ik heb
[CPP]#include <iostream>
int main()
{
int i;
i = 0;
while (i < 5)
{
cout << "de huidige waarde van i is "; //hier tot een error
cout << i;
cout << "\n";
i = i + 1;
}
//cout << "\n Druk op enter om door te gaan..."
//getchar();
cin.get();
return 0;
}[/CPP]

en om 1 of andere reden geeft het ding een error met het bericht:
[CPP]8 C:\Documents and Settings\Maarten\My Documents\whilelus.cpp `cout' undeclared (first use this function) [/CPP]

 

[CoD_NL]

cout bevindt zich in de namespace std. Om het probleem op te lossen kun je het volledig schrijven (std::cout), of je maakt gebruik van using directives (using namespace std of using std::cout).

[cpp]
#include <iostream>


int main()
{
int i = -1;
while (++i < 5)
{
std::cout << "de huidige waarde van i is " << i << '\n';
}
return 0;
}
[/cpp]

 

[pinda kaas]

nieuw

ik probeer nu een class aan te maken en er komt een error over een {???

[CPP]#include <iostream>

class monster;
{ //hier is de error
public:
int x_coordinaat;
int y_coordinaat;
void verplaats(int, int);
void initialiseer(int, int)

}

void monster::initialiseer(int init_x, int init_y)
{
x_coordinaat = init_x;
y_coordinaat = init_y;
}

void monster::verplaats(int nieuw_x, int nieuw_y)
{
x_coordinaat = x_coordinaat + nieuw_x
y_coordinaat = y_coordinaat + nieuw_y
}

int main()
{
monster zombie;
zombie.initialiseer(12, 15);
cout << "De x-locatie van de zombie is " << zombie.x_coordinaat << "\n";
cout << "De y-locatie van de zombie is " << zombie.y_coordinaat << "\n";

}[/CPP]

en de error die word gegeven:
4 C:\Documents and Settings\Maarten\My Documents\classe.cpp expected unqualified-id before '{' token

 

[CoD_NL]

En je hebt alweer een probleem met een puntkomma (die heb je achter de klasse naam staan, terwijl die eigenlijk aan het einde van de klasse moet).

Ik heb je even een goed voorbeeld gemaakt, maar heb nu niet de tijd/zin om alles uit te leggen. Maar daar kom ik later nog op terug.

[cpp]
#include <iostream>

class Monster {
/* private */
int x_coordinaat;
int y_coordinaat;
public:
int GetX() const;
int GetY() const;
void SetX(const int);
void SetY(const int);
void Verplaats(const int, const int);
void Initialiseer(const int, const int);
};

int Monster::GetX() const {
return x_coordinaat;
}

int Monster::GetY() const {
return y_coordinaat;
}

void Monster::SetX(const int x) {
x_coordinaat = x;
}

void Monster::SetY(const int y) {
y_coordinaat = y;
}

void Monster::Verplaats(const int x, const int y) {
x_coordinaat += x;
y_coordinaat += y;
}

void Monster::Initialiseer(const int x, const int y) {
x_coordinaat = x;
y_coordinaat = y;
}

int main()
{
Monster zombie;
zombie.Initialiseer(12, 15);
cout << "De x-locatie van de zombie is " << zombie.GetX() << "\n";
cout << "De y-locatie van de zombie is " << zombie.GetY() << "\n";
system("PAUSE");
return EXIT_SUCCESS;
}[/cpp]

 

[CoD_NL]

Zoals eerder beloofd komt hier een toelichting om de gebruikte code:

[cpp]
class Monster {
/* private */
int x_coordinaat;
int y_coordinaat;
// een beschrijving waarom deze variabelen private zijn vind je bijvoorbeeld op: http://www.exforsys.com/tutorials/c-plus-plus/encapsulation--an-introduction.html
public:
int GetX() const; // const wil in dit geval zeggen dat de functie de klasse niet wijzigt
int GetY() const;
void SetX(const int); // const wil in dit geval zeggen dat het argument niet gewijzigd kan worden binnen de functie
void SetY(const int);
void Verplaats(const int, const int);
void Initialiseer(const int, const int);
};
[/cpp]

Het gebruik van const is uiteraard niet verplicht (meer daarover: http://en.wikipedia.org/wiki/Const-correctness).

 

[Arjan B]

Misschien is het gewoon om een voorbeeld te geven, maar waarom maak je set() én get() functies aan voor eenzelfde variabele, zonder dat die extra checks toevoegen of iets dergelijks? Kun je die variabele dan niet net zo goed public maken?

 

[CoD_NL]

Misschien is het gewoon om een voorbeeld te geven, maar waarom maak je set() én get() functies aan voor eenzelfde variabele, zonder dat die extra checks toevoegen of iets dergelijks? Kun je die variabele dan niet net zo goed public maken?

Op die manier scherm je de clients af voor wijzigingen aan de implementatie. Strict genomen is het opslaan van de coördinaten in twee integers bijvoorbeeld slechts een implementatie-detail en zou gewijzigd kunnen worden. Indien de variabelen public gemaakt zijn en je doet een wijziging aan de implementatie, dan breek je daarmee meteen de code van alle clients die gebruik maken van die implementatie. En dat lijkt me niet de bedoeling (Monster m -> int xpos, ypos => Pos p; Dan zou je overal m.xpos moeten vervangen voor m.p.X()). In mijn voorbeeld blijven de clients gewoon werken zolang de interface maar niet gewijzigd wordt.

Een realistischer voorbeeld is bijvoorbeeld het opslaan van een bericht, waarbij er besloten wordt om van een char pointer naar een string te gaan:

[cpp]
// oude implementatie
class foo1 {
public:
char *s;
};

// nieuwe implementatie
class foo2 {
public:
std::string s;
};


int main() {
foo1 f1;
foo2 f2;

f2.s = f1.s = "blaat"; // code is in beide gevallen hetzelfde en blijft dus gewoon werken

int f1len = strlen(f1.s); // het opvragen van de lengtes werkt niet hetzelfde en de code zal
int f2len = f2.s.length(); // in dit geval ook herschreven moeten worden om het gewenste resultaat te bereiken
// int f3len = f3.Lengte() werkt altijd en de code hoeft niet te worden herschreven

return 0;
}
[/cpp]

Voor de clients is het niet van belang hoe het onder de motorkap werkt, als het maar doet wat ervan verwacht wordt. (je hebt wel altijd goede posts, dus als ik ergens fout zit hoor ik het graag)

 

[Arjan B]

Ik zag dan die variabelen x en y als deel van de interface.
Maar je hebt gelijk, als het later nodig blijkt dat bij het toekennen van een waarde aan x of y dat de nieuwe waarde ergens aan voldoet, dan werkt dit niet meer. En dan moet je inderdaad je interface veranderen, waardoor je alle code die daar gebruik van maakt opnieuw moet nachecken.

Als ik het zelf zou doen, zou ik iets in deze richting doen:
[CPP]
struct Positie {
int x, y;
};

class Monster {
Positie positie;
public:
Monster(Positie p);

Positie GetPositie();
void Verplaats(Positie p);
};
[/CPP]

 

[CoD_NL]

Met die oplossing is niks mis, maar normaal gesproken heb je nog meer game-karakters dan alleen monsters. Elk game-karakter heeft ook dezelfde basiseigenschappen, dus daar zou je een basisklasse van kunnen maken. Iets als:

[cpp]
class GameObj {
protected:
int xpos, ypos; // of gewoon Positie positie
public:
GameObj(const int x, const int y) : xpos(x), ypos(y) {}
virtual ~GameObj() {}
void SetX(const int x) { xpos = x; }
void SetY(const int y) { ypos = y; }
int GetX() const { return xpos; }
int GetY() const { return ypos; }
virtual void Print() const = 0;
// ...
};

class Monster : public GameObj {
public:
Monster(const int x, const int y) : GameObj(x, y) {}
virtual void Print() const {
std::cout << "Monster@" << xpos << "," << ypos << '\n';
}
};

class Speler : public GameObj {
public:
Speler(const int x, const int y) : GameObj(x, y) {}
virtual void Print() const {
std::cout << "Speler@" << xpos << "," << ypos << '\n';
}
};

// Speler s(10,20);
// Monster m(40,50);
// s.Print();
// m.Print();
[/cpp]