Ik zal de code even becommentarieren:
#include <stdio.h>
#include <stdlib.h>
#define cnew(x) x##_create
#define cdelete(x,y) x##_destroy(y); y = 0
Dit zijn twee macro's die de werking van new en delete in C++ simuleren: cnew creëert een nieuwe variable van type x, cdelete verwijdert variable y van type x, en zet de pointer op 0.
struct node {
int val;
struct node *left;
struct node *right;
};
Dit heb ik gewoon gekopieerd van jouw code
struct node *node_create() {
struct node *n = (struct node*)calloc(sizeof(struct node),1);
return n;
}
Dit is de
constructor van node. Functies die op een object werken beginnen altijd met de naam van de klasse en een underscore in dit schema (Ik heb dit schema voor OOP in C zelf onworpen). De constructor wordt aangeroepen door
cnew. De constructor moet een pointer naar de klasse retourneren, en neemt als enige geen T *self aan. Ik gebruik hier
calloc om de variabelen onmiddelijk op 0 te zetten.
void node_destroy(struct node *self) {
if(self->right != NULL) cdelete(node,right);
if(self->left != NULL) cdelete(node,left);
free(self);
}
Dit is de
destructor, deze wordt door cdelete aangeroepen. Hier zie je dus een andere functie die op een object werkt (in andere talen met 'echte' klassen heet dit een memberfunctie). Deze neemt wél een pointer naar het object aan. Eerst worden de bladeren links en rechts verwijderd (tenzij ze 0 zijn), daarna wordt het object zelf verwijderd d.m.v.
free void node_append(struct node *self, int val) {
struct node* leafptr = self;
while(leafptr != 0) {
if(leafptr->val < val) leafptr = leafptr->left;
else leafptr = leafptr->right;
}
leafptr = cnew(node)();
leafptr->val = val;
}
Dit is hetzelfde als je insert_val_tree. Weer een functie die op een object werkt, met de prefix en de pointer naar self (je mag overigens elke naam voor self kiezen die je wilt: ik gebruik gewoon self uit stijl, en om niet 'this' te gebruiken, wat conflicteert met C++). We itereren zolang over de tree totdat we een leeg plaatsje gevonden hebben: afhankelijk of de waarde kleiner of groter is gaan we naar links of naar rechts. Dan alloceren we een nieuw object (geen schrik, de destructor geeft ze allemaal vrij!), en vullen de gegeven in.
int main()
{
struct node *root = cnew(node)();
node_append(root,5);
printf("%d",root->val);
cdelete(node,root);
return 0;
}Dit heb ik gewoon gekopiëerd. Enkel heb ik hier cnew en cdelete gebruikt in plaats van malloc (de constructor en destructor moeten zelf voor hun malloc/free zorgen).
Ik hoop dat je hier iets aan hebt en wat bij hebt geleerd over object geörienteerd programmeren in C. Je hoeft mijn stijl niet te volgen, je kan even goed je eigen stijl ontwikkelen
