C++: Classes...

ik wil gewoon ff klooten met C++...
Maar ik komt er niet uit...

Ik wil een class hebben (zeg obj2) die afstamt van obj1, en die dus ook de properties mee neemt.

Ik heb dit:

#include <stdio.h>
#include <stdlib.h>

class obj1
{
  public:
    int width;
    obj1();
    ~obj1();
        
};

obj1::obj1(){ width = 5; };
obj1::~obj1(){ width = 0; };

class obj2 friend obj1
{
  public:
    int height;
    obj2();
    ~obj2();
};

obj2::obj2(){ height = 10; };
obj2::~obj2(){};

void main( void )
{
    obj2  test;
    
    printf( "%d || %d", test.width, test.height);
    system( "PAUSE" );
}

De foutmelding die ik krijg:
`class obj2' has no member named `width'

Ik wil dus een subclass maken...

[Tampert]

hmmnzzz...

okee informatica valt onder dit forum... maar ik denk dat ze dit bij S&M veeeel beter kunnen beantwoorden dusssss

http://********.tsd-webservices.nl/t...envatting.html

Lees en huiver

Naar jouw voorbeeld:

#include <iostream.h>

class obj1
{
public:
  int width;
  obj1();
};

class obj2 : public obj1
{
public:
  int height;
  obj2();
};

obj1::obj1()
{
  width = 5;
}

obj2::obj2()
{
  height = 10;
}

int main()
{
  obj2 test;
  cout << test.width << "\n" << test.height << "\n";
  getchar();
}

:)

[Tofke_H]

Je vraag lijkt me beantwoord maar mag ik je vragen hoe jij aan obj1::~obj1() komt? Ik kan me niet herinneren dat ik bij C of C++ een ~ heb gebruikt bij dergelijke dingen.

Tofke_H schreef:
Je vraag lijkt me beantwoord maar mag ik je vragen hoe jij aan obj1::~obj1() komt? Ik kan me niet herinneren dat ik bij C of C++ een ~ heb gebruikt bij dergelijke dingen.

Hij definieert de destructor expliciet buiten de klasse Geheel zinloos, aangezien deze hier geen nuttige functie heeft. Hij kan wel leuk die variabelen op 0 gaan zetten, maar ze worden een tel later verwijderd uit het geheugen

******** schreef:
Naar jouw voorbeeld:
*code*

Dank!

Okee... dat is één...
Vraag 2:
Ik heb 3 objecten/classes (obj1, obj2 en obj3). In obj3 wil ik dmv een functie (iets in de trand van addObject() ) een object kunnen toevoegen. Dit kan obj1, obj2 of obj3 zijn. Aan elk van deze toegevoegde objecten, moet ik ook weer objecten kunnen toevoegen, etc...

Ik wil een array hebben (objects) waarin de objecten staan die ik heb toegevoegd, dus bijvoorbeeld:

obj3 test;

test.addObject( <iets> );
test.addObject( <iets anders> );
test.objects[0].addObject( <iets> );

De functie addObject moet dus in elke class zitten. Er mag bijvoorbeeld een 'masterclass' zijn met deze functie, waar de overige classes van afstammen.

Maak het svp niet tè moeilijk

******** schreef:
Hij definieert de destructor expliciet buiten de klasse Geheel zinloos, aangezien deze hier geen nuttige functie heeft. Hij kan wel leuk die variabelen op 0 gaan zetten, maar ze worden een tel later verwijderd uit het geheugen

Jah... boeie!

Ik was druk bezig met pointers en dynamissche geheugelallocaties (niet dat ik het kan ), enja... dan ga je vanzelf die functies definieren...

[McMotion]

zoiets?

#include <memory.h>
#define MAX_ITEMS 100;

class TreeNode
{
public:
	int AddNode(TreeNode *Node);
	bool RemoveNode(int iNodeNumber);
	TreeNode *Node(int iNodeNumber);
protected:
	int iNodeCount = 0;
	TreeNode *aSubObjects[MAX_ITEMS];
}

class obj1 : public TreeNode
{
public:
	void Member1();
	void Member2();
}

class obj2 : public TreeNode
{
public:
	void Member1();
	void Member2();
	void Member3();
}

class obj3 : public TreeNode
{
public:
	void MemberA();
	void MemberB();
}

int TreeNode::AddNode(TreeNode *Node)
{
	if(iNodeCount == MAX_ITEMS) return -1;
	aSubObjects[iNodeCount] == Node;
	return iNodeCount++;
}

int TreeNode::RemoveNode(int iNodeNumber)
{
	memcpy(&aSubObjects[iNodeNumber], &aSubObjects[iNodeNumber+1], (iNodeCount - iNodeNumber - 1) * sizeof(TreeNode));
	return --iNodeCount;
}

TreeNode *TreeNode::Node(int iNodeNumber)
{
	return aSubObjects[iNodeNumber];
}

[McMotion]

eddie schreef:

Jah... boeie!

Ik was druk bezig met pointers en dynamissche geheugelallocaties (niet dat ik het kan )

ooops je wilde het toch statisch in arrays? dacht ik uit je voorgaande posts op te maken

McMotion schreef:



ooops je wilde het toch statisch in arrays? dacht ik uit je voorgaande posts op te maken

Jup, was eigenlijk wel de bedoeling...

Dat je dus 'new' en 'delete' gebruikt om je subobjecten te maken en verwijderen.

Toch bedankt voor je moeite!

*heeft weer iets geleerd*

Ik zal misschien later even de code posten die ik heb...

[McMotion]

dan moet je er een linked list van maken dus in elke treenode een pointer naar de volgende treenode.. ik zal zo wel ff die code van mij aanpassen

Hmm... met een linked list kan ik de subclasses niet direct benaderen...

Mijn code (geexporteerd met Dev-C++)

Ik hoop dat mijn idee duidelijk is

Ik heb nu niet zoveel tijd .. maar hier even een voorbeeld waar een ouder meerdere kinderen in een array van pointers heeft staan (had ik nog van mijn opleiding):

#include <iostream.h>

//
// Containers? Testje..
//

class kind
{
public:
  kind() { leeftijd = 0; };
  kind(int L) { leeftijd = L; };
  int leeftijd;
};

typedef kind * pkind; // pkind is een pointer naar kind

class ouder
{
  pkind *pKindjes;
  int aantal;
public:
  ouder();
  ~ouder();
  void krijgkind(kind *K);
  kind& geefkind(int i);
};

ouder::ouder()
{
  // initialisatie
  aantal = 0;
}

ouder::~ouder()
{
  // opruimen
}

void ouder::krijgkind(kind *K)
{
  pkind *tmp;
  aantal++;
  tmp = new pkind[aantal];
  if(aantal > 1) {
    for(int i = 0; i < (aantal - 1); i++) {
      tmp[i] = pKindjes[i];
    }
  }
  tmp[aantal - 1] = K;

  pKindjes = tmp;

  cout << "add: [" << aantal - 1 << "] " << pKindjes[aantal - 1]->leeftijd << "\n";
}

kind& ouder::geefkind(int i)
{
  return *pKindjes[i];
}

int main()
{
  kind A(5);
  kind B(7);
  kind C(9);

  ouder O;
  O.krijgkind(&A);
  O.krijgkind(&B);
  O.krijgkind(&C);

  cout << "0 : " << O.geefkind(0).leeftijd << "\n";
  cout << "1 : " << O.geefkind(1).leeftijd << "\n";
  cout << "2 : " << O.geefkind(2).leeftijd << "\n";

  getchar();

  return 0;
}

Misschien heb je er iets aan .. ik ben weg hier kan zijn dat ik er morgen nog ff naar kijk

******** schreef:
Ik heb nu niet zoveel tijd .. maar hier even een voorbeeld waar een ouder meerdere kinderen in een array van pointers heeft staan (had ik nog van mijn opleiding):

*code*

Misschien heb je er iets aan .. ik ben weg hier kan zijn dat ik er morgen nog ff naar kijk

En probeer nu eens de functie geefKind( int ) om te bouwen naar een array, als in:

O.kind[0].leeftijd;

Functie driven wil ik niet... Lijkt te veel op Java *brrrr*

Dan zul je een containing-relatie moeten opbouwen en de [] operator moeten overloaden. Lees mijn samenvatting maar eens goed door

We gaan niet al het werk voor je doen

[McMotion]

******** schreef:
Dan zul je een containing-relatie moeten opbouwen en de [] operator moeten overloaden. Lees mijn samenvatting maar eens goed door

We gaan niet al het werk voor je doen

idd via overloading... rechtstreeks pointers naar de objecten is niet echt aan te raden bij object georienteerd programmeren

McMotion schreef:
rechtstreeks pointers naar de objecten is niet echt aan te raden bij object georienteerd programmeren

Nee, ik snap

Krijg je nogal een zooitje als een object out of scope gaat / ophoudt te bestaan. De pointers wijzen dan naar geheugenadressen die onderwijl misschien door andere objecten worden gebruikt. Idd niet zo slim van me

******** schreef:
Dan zul je een containing-relatie moeten opbouwen en de [] operator moeten overloaden. Lees mijn samenvatting maar eens goed door

We gaan niet al het werk voor je doen

Ach ja... tuurlijk... overloading...

En je hoeft niet al het werk te doen... alleen even een voorbeeldje in elkaar frutselen

[Chimera]

eddie schreef:

En je hoeft niet al het werk te doen... alleen even een voorbeeldje in elkaar frutselen

Nja. Koop een boek De C++ Primer van Stroustroup (ofzo, de C++ 'uitvinder') is een aanrader.

Chimera schreef:
Nja. Koop een boek ;) De C++ Primer van Stroustroup (ofzo, de C++ 'uitvinder') is een aanrader.

Waarschuwing: dit boek is erg dik :D *is in het bezit ervan* :)

Hieronder even een voorbeeld van operator overloading:

//
// Voorbeeld van operator overloading
//

#include <iostream.h>

#define MAX_AR 10

class voorbeeld
{
  int ar[MAX_AR]; // array van MAX_AR integers
public:
  voorbeeld(); // constructor
  int& operator [] (int i);
};

voorbeeld::voorbeeld()
{
  // Initialiseer alle elementen van de array op 0
  for(int i = 0; i < MAX_AR; i++) ar[i] = 0;
}

// Het overloaden van de [] operator
int& voorbeeld::operator [] (int i)
{
  return ar[i];
}

int main()
{
  voorbeeld Test;
  Test[0] = 1;
  Test[1] = 2;
  Test[2] = 3;

  cout << Test[0] << "\n";
  cout << Test[1] << "\n";
  cout << Test[2] << "\n";

  getchar();

  return 0;
}

Je kunt nu trouwens een controle inbouwen op de parameter daarmee kun je memory overwrites voorkomen en dergelijke

ik had zelf ook al iets geprobeerd met operator overloading...

Maar het werkte niet echt goed. Ik wou n.l. 2 (of meer) strings bij elkaar optellen... (a = "Blaat" + " whooie")

En ja, dat kan niet in C++... Dus die wou ik overloaden, maar... ik snapte het niet

In jou voorbeeld, waar word die overload toegepast?
Bij:
Test[0] = 1;

of bij
cout << Test[0];

Is imo wel belangrijk om te weten...

******** schreef:
Waarschuwing: dit boek is erg dik *is in het bezit ervan*

Hoe dik?
Hoeveel A4 kantjes?

Ik heb nl AOA uitgeprint in de kast liggen, en dat zijn ongeveer 1536 A4 kantjes...

eddie schreef:
Hoe dik?
Hoeveel A4 kantjes?

ff kijken

..

1019

******** schreef:
ff kijken

..

1019

ISB nummer?
*gaat hem misschien kopen*

Staat er ook in hoe je met Windows API's moet werken?

class voorbeeld
{
public:
  int& operator [] (int i);
};

Hier maak ik bekend in het protocol van de klasse voorbeeld dat ik de [] operator overloaden wil. Het return-type is een simple reference naar een integer, hetgeen betekent dat ik de return-waarde van de functie direct manipuleren kan.

int& voorbeeld::operator [] (int i)
{
  return ar[i];
}

Dit is de definitie van de overloaded functie. Ik return een reference naar een integer in mijn array, waardoor deze beschikbaar wordt.

Test[0] = 1;

Test[0] geet mij een reference naar ar[0], welke ik met de assignment operator = een waarde van 1 toeken.

cout << Test[0] << "\n";

Test[0] geeft mij wederom ar[0], welke ik deze keer uitvoer

Veel valt er nu niet meer aan uit te leggen

******** schreef:
<uitleg>

Veel valt er nu niet meer aan uit te leggen

Oohh...

Ik snap het!

eddie schreef:
ISB nummer?
*gaat hem misschien kopen*

Euhm .. ff zoeken

Er staat achter op: ISBN 0-201-70073-5

Staat er ook in hoe je met Windows API's moet werken?

Nee.

De Windows API's staan los van C++. Hiervoor zul je een Win32API reference moeten zoeken, of MFC (Visual Studio / C++) of wel VCL/CLX (Borland Builder en Kylix), welke beide C++ wrappers voor de Win32API zijn, moeten leren.

Sterkte

******** schreef:
Euhm .. ff zoeken

Er staat achter op: ISBN 0-201-70073-5

Wat duur...
Bol.com

******** schreef:

Nee.

De Windows API's staan los van C++. Hiervoor zul je een Win32API reference moeten zoeken, of MFC (Visual Studio / C++) of wel VCL/CLX (Borland Builder en Kylix), welke beide C++ wrappers voor de Win32API zijn, moeten leren.

Okee... ik kijk wel op msdn.microsoft.com/library

******** schreef:

Sterkte

Dank!

[McMotion]

******** schreef:

class voorbeeld
{
public:
  int& operator [] (int i);
};

Hier maak ik bekend in het protocol van de klasse voorbeeld dat ik de [] operator overloaden wil. Het return-type is een simple reference naar een integer, hetgeen betekent dat ik de return-waarde van de functie direct manipuleren kan.

dan geef je alsnog een pointer terug naar je data in het object zelf... okay noem het een reference variabel als je wil, maar het blijft hetzelfde

McMotion schreef:
dan geef je alsnog een pointer terug naar je data in het object zelf... okay noem het een reference variabel als je wil, maar het blijft hetzelfde

Het is misschien lichtelijk in strijd met de data encapsulatie .. maar je kunt het ook overdrijven

[McMotion]

jah maar dan kan je die ampersand toch ook gewoon weglaten, is nog minder tiepwerk ook!

McMotion schreef:
jah maar dan kan je die ampersand toch ook gewoon weglaten, is nog minder tiepwerk ook!

Maar dan werken die assignments niet meer zou je dus een extra methode voor moeten schrijven..

Waarom werkt dit niet?
In c zou "blub" moeten staan, maar op de derde posistie staat een "?"

Code

[McMotion]

******** schreef:
Maar dan werken die assignments niet meer zou je dus een extra methode voor moeten schrijven..

idd.. ook weer overloaden
wat je allemaal wel niet over moet hebben voor data hiding!

[McMotion]

maar wat ik niet begrijp eddie... waarom moet het op een array lijken
waarom niet gewoon een GetChild(int) functie?
da's veel logischer vind ik

McMotion schreef:
maar wat ik niet begrijp eddie... waarom moet het op een array lijken
waarom niet gewoon een GetChild(int) functie?
da's veel logischer vind ik

Een array is mooier...

En zie mijn sig...

[McMotion]

tja mooier is jouw mening maar het is geen goeie programmeerstijl... je moet er gewoon niet aan wennen bij OOP.. je moet het juist proberen te voorkomen!

McMotion schreef:
tja mooier is jouw mening maar het is geen goeie programmeerstijl... je moet er gewoon niet aan wennen bij OOP.. je moet het juist proberen te voorkomen!

Maar hoe kan ik dat zorgen dat ik een array krijg (die ik dan kan benaderen via getObject() ofzo) dat uit verschillende objecten kan bestaan?

eddie schreef:
Maar hoe kan ik dat zorgen dat ik een array krijg (die ik dan kan benaderen via getObject() ofzo) dat uit verschillende objecten kan bestaan?

Het is bij OOP niet de bedoeling dat je objecten direct benadert (versterkt namelijk de koppeling)

Een zwakke onderlinge koppeling tussen objecten en een sterke cohesie (gegevens en methoden horen bij elkaar per object) bevorderen de kwaliteit (onderhoudbaarheid) van programmatuur.

******** schreef:
Het is bij OOP niet de bedoeling dat je objecten direct benadert (versterkt namelijk de koppeling)

Een zwakke onderlinge koppeling tussen objecten en een sterke cohesie (gegevens en methoden horen bij elkaar per object) bevorderen de kwaliteit (onderhoudbaarheid) van programmatuur.

huh

niet zulke 'moeilijke' woorden gebruiken svp, ik snap er niks van!

eddie schreef:
niet zulke 'moeilijke' woorden gebruiken svp, ik snap er niks van!

Ach, ik herhaal ook alleen maar wat ik voor mijn examen weten moest

Maar je kunt een GetObject functie toch gewoon een reference laten retourneren? Aan de andere kant is het beter om in de klasse zelf functie's te definieren die bewerkingen uitvoeren op de childs .. zo werkt je code alleen op die ene klasse, en niet direct met de childs. Dat bedoelde ik dus.

Dus niet:

MyObj->GetObject(x)->MyVal = y;
cout << MyObj->GetObject(x)->MyVal;

Maar:

MyObj->SetVal(x, y);
cout << MyObj->GetVal(x);

Bij wijze van .. het gaat om het principe van data hiding.

******** schreef:
MyObj->GetObject(x)->MyVal = y;
cout << MyObj->GetObject(x)->MyVal;

MyObj->GetObject(x)->SetValue(y);
MyObj->GetObject(x)->GetValue();

Zou ook kunnen eigenlijk. Als je maar niet direct met de implementatie werkt.

ja, ok.. boeie!

Maar hoe moet de functie GetObject eruit zien? Van welk type is x?


Volgens mij wil ik iets heeeeeel moeilijks, terwijl ik nog een ver-beginner ben...

Trouwens, Win2k gaat anders om met het geheugen dan Win98

Nu werkt mijn mooie string-class niet meer

http://home.wanadoo.nl/tsd-mas/dump/parentchild.cpp.txt

Een voorbeelde child / parent class .. deze keer met data hiding

leuk, maar wat nou als je in plaats van één class 'cKind', twee classes, 'cJongen' en 'cMeisje' hebt?

Dat bedoel ik. Hoe los je dat op?

PS: Beide classes kunnen gebaseerd zijn op de class 'cKind'

eddie schreef:
leuk, maar wat nou als je in plaats van één class 'cKind', twee classes, 'cJongen' en 'cMeisje' hebt?

Dat bedoel ik. Hoe los je dat op?

PS: Beide classes kunnen gebaseerd zijn op de class 'cKind'

Dat zou je op meerdere manieren kunnen doen.

Je kunt bijvoorbeeld de eigenschap Geslacht toevoegen aan de klasse cKind. Dat is het eenvoudigste..

******** schreef:
Dat zou je op meerdere manieren kunnen doen.

Je kunt bijvoorbeeld de eigenschap Geslacht toevoegen aan de klasse cKind. Dat is het eenvoudigste..

Arrrrgh!!
Je wilt me niet snappen hè?

Het gaat erom of het mogelijk is (en dat ik dan weet hoe het moet)

eddie schreef:
Arrrrgh!!
Je wilt me niet snappen hè?

Het gaat erom of het mogelijk is (en dat ik dan weet hoe het moet)

Het is niet logisch en zinnig.

Maar in principe zou je dan met een base klasse werken .. het nadeel is dat extra eigenschappen verloren gaan, tenzij je met pointers werkt .. en dat wordt dus afgeraden..