Quellcode

void* add(char typ, void* a, void* b)
{
void* res = NULL;

switch (typ)
{
case 'i':
res = new int(*(int*)a + *(int*)b);
break;
case 'f':
res = new double(*(double*)a + *(double*)b);
break;
case 's':
// insert string concatenation code here
break;
}

return res;

}

Quellcode

case 's':
{
int a_len = strlen((char*)a); // länge von a ermitteln
int b_len = strlen((char*)b); // länge von b
int sum = a_len + b_len + 1; // länge des neuen strings (+1 wegen der zero-termination)
res = malloc(sizeof(char) * sum); // speicher für den neuen string allokieren

// string a in allokierten speicher kopieren
memcpy(res, a, sizeof(char)*(a_len+1)); // wir kopieren den zero-terminator mit
// selbiges für string b (diesmal mit strcat)
strcat(res, b); // strcat löscht den terminator und fügt den kompletten string b an
break;
}
......

Quellcode

void* sub(char typ, void* a, void* b)
{
void* res = NULL;
 
switch (typ)
{
case 'i':
res = new int(*(int*)a - *(int*)b);
break;

case 'f':
res = new double(*(double*)a - *(double*)b);
break;

case 's':
{
int a_len = strlen((char*)a); // länge von a
int b_len = strlen((char*)b); // länge von b
int new_len = a_len - b_len + 1; // voraussichtliche länge des neuen strings bei entfernung des substrings

res = strstr((char*)a, (char*)b); // substring suchen, wir nehmen mal res als ergebnis, es enthält ja sonst nix

if (res == NULL)
return a; // ist vielleicht nicht ganz optimal, man sollte es vielleicht vorher in einen neuen speicherbereich kopieren - ist dann sicherer wegen des mem-management

// wenn wir hier ankommen ist der substring wirklich in a enthalten

res = malloc(sizeof(char) * new_len); // speicher für den neuen string allokieren

// achtung: pointer arithmetik, das kann in die hose gehen, überlegt euch lieber eine bessere methode

int rel_pos = int(a - res); // relative position des substrings vom anfang des strings a errechnen
// ist auch gleichzeitig die anzahl der zeichen, die sich vor dem substring befinden, den es zu entfernen gilt - die müssen kopiert werden!

// soviel von string a in den neu allokierten speicher kopieren, bis wir die stelle des substrings (relative position) ereicht haben
memcpy(res, a, sizeof(char) * rel_pos);

// den rest ohne den substring kopieren
memcpy(res + rel_pos, a + rel_pos + b_len, sizeof(char) * (new_len - (rel_pos + b_len)));

// erklärung zum o.g. aufruf
// ziel: res + rel_pos (res zeigt immer noch auf den anfang des allokierten blocks, wenn wir jetzt dahin kopieren überschreiben wir gleich wieder da, was wir vorher geschrieben haben. deshalb zählen wir auf die startadresse die anzahl der schon kopierten bytes drauf (rel_pos))
// quelle: a + rel_pos + b_len (quelle ist wie man sieht der string a, allerdings überspringen wir zuerst den schon kopierten bereich (+ rel_pos) und danach den substring, den wir ja nicht mitkopieren wollen (+ b_len))
// count: sizeof(char) * (new_len - (rel_pos + b_len))
// anzahl der zu kopierenden bytes (das wäre die länge des neuen strings (schon oben berechnet) minus der substring-länge (b_len) und natürlich des schon kopierten strings aus a (rel_pos))

// thats all I think... *g*

break;
}

default:
cout << "error! no valid type for calculation supplied!\n";


}

return res; // ergebnis der berechnung zurückliefern

}