U
while ('\0' != Text[i] && '&' != Text[i])
{
NewText[j] = Text[i];
i++;
j++;
}
dafür gibts übrigens nen std::copy (aus dem algorithms header) ^^
char * NewText = new char [255];
/*...*/
return NewText;
fällt dir was auf?
mir schon: das delete[] fehlt - geht auch schlecht, weil du das ergebnis ja brauchst... also musst du in deinem quelltext das delete noch nehmen -> stinkt alles, weil man das new nicht sieht aber trotzdem nen delete[] aufrufen muss...
also geht man idR den Weg über ne Release-Funktion, die das delete[] aufruft - hässlich ist es immernoch...
außerdem hast du die länge dort theoretischerweise schon - ist zwar ein wenig mehr arbeit, aber dafür geht es eben auch mit mehr als 254 zeichen und zudem wird nicht jedes mal ewig viel speicher für vll 20 zeichen angefordert...
btw:
warum will dein lehrer kein std::string? soll aber schon C++ sein, was du dort lernst?
zum eigtl programm/problem:
char * VarParse (char *const& Text, char *const& SearchTerm);
hässlicher gehts au nimmer!? -.-
außerdem sollte das so auch gar net gehen!? Oo
char * VarParse (const char *Text, const char *SearchTerm);
so sollte es (wenn man deinem quelltext glaubt) stimmen - allerdings wirst du wahrscheinlich den Zeiger auf Text verändern müssen (damit du beim zweiten mal parsen nicht noch mal das erste parst ^^) - also sowas:
char * VarParse (char *& Text, const char *SearchTerm);
das hier meinte ich:
char* VarParse (char *& Text, const char *SearchTerm);
int main()
{
char t[3];
t[0] = '0';
t[1] = '1';
t[2] = '\0';
char* aktuelle_pars_position = &t[0];
char* fertig = aktuelle_pars_position + strlen(aktuelle_pars_position);
while (aktuelle_pars_position != fertig)
{
char *a = VarParse (aktuelle_pars_position, "asd");
std::cout << a;
}
}
char * VarParse (char *& Text, const char *SearchTerm)
{
++Text; //man kann Text ändern - und verändert damit den übergebenen zeiger nicht nur lokal (dafür ist ja das '&' da)
return "asd";
}
jz kann man auch endlich den ganzen string parsen ^^
jetzt haben wir nur noch das problem, dass das, was wir zurückgeben, bis jz statisch ist und deshalb noch das delete entfällt - so einfach wollen wir uns das aber ma nich machen:
normalerweise würd ich jz ja ne kleine klasse schreiben, die nur nen zeiger auf der erste und auf das letzte byte hält (da die ausgabe ja immer nen teil der eingabe ist und nicht verändert werden soll)- aber da du meintest ohne oop, wird das ein wenig schwer ^^
#include <algorithm> //std::copy
//call ReleaseVarParse(char*) for releasing the memory
char * VarParse (char *& Text, const char *SearchTerm)
{
/*strstr, ...*/
int length = 0;
for (char *i(Text); *i != '\0'; ++i, ++length)
{
if(*i == '&')
break;
}
char *returnval = new char[length+1];
std::copy(Text, Text+length, returnval);
returnval[length] = '\0';
Text += length+1;
return returnval;
}
void ReleaseVarParse (char *value)
{
delete[] value;
}
int main()
{
char* input = "variable1=variable1-inhalt&string=string-inhalt";
char* aktuelle_pars_position = input;
char* fertig = aktuelle_pars_position + strlen(aktuelle_pars_position);
while (aktuelle_pars_position != fertig)
{
char *a = VarParse (aktuelle_pars_position, "asd");
std::cout << a;
ReleaseVarParse (a);
}
}
alles andere, als hübsch, aber es funktioniert... so ganz ohne speicherlecks und so ^^
bb
