speicher waechst wie von zauberhand..

unsigned char *append_part_string(unsigned char *part, unsigned char *full_string)
{
	int len = 0;
	unsigned char *tmp = NULL;

	len = strlen(full_string);

	tmp = (unsigned char*)malloc(len);
	memset(tmp, 0, len);

	strcpy(tmp, full_string);

	free(full_string);
	full_string = NULL;

	len += (len == 76 ? 6 : 4);

	printf("strlen(tmp)=%i\n", strlen(tmp));	
	full_string = (unsigned char*)malloc(len); //hier passierts..
	printf("strlen(tmp)=%i\n", strlen(tmp));
	memset(full_string, 0, len);

	strcpy(full_string, tmp);
	strcat(full_string, part);

		if ( len == 76 )
		{
			strcat(full_string, "\r\n");
		}

	tmp = NULL;

	return (full_string);
}

ausgabe des programms:

strlen(tmp)=4
strlen(tmp)=4
strlen(tmp)=8
strlen(tmp)=8
strlen(tmp)=12
strlen(tmp)=13
strlen(tmp)=17
strlen(tmp)=17
strlen(tmp)=21
strlen(tmp)=21
strlen(tmp)=25
strlen(tmp)=25
strlen(tmp)=29
strlen(tmp)=29
strlen(tmp)=33
strlen(tmp)=33

die differenz der ausgegebenen zahlen sollte immer 4 betragen. tut sie meistens auch, bis auf dieses eine mal, alle weiteren zahlen weisen immer 4 als differenz auf.

nun, wenn ich bei der besagten zeile statt "len" "len+1" schreibe, funktioniert alles ohne probleme. kann mir jemand sagen wieso?

falls es jemand testen will, soll ers sagen, ich poste dann den vollstaendigen code.

danke

kleiner nachtrag:
auch mit dem "len+1" siehts ein wenig spaeter so aus:

strlen(tmp)=64
strlen(tmp)=64
strlen(tmp)=68
strlen(tmp)=68
strlen(tmp)=72
strlen(tmp)=72 <<
strlen(tmp)=78 <<
strlen(tmp)=78
strlen(tmp)=82
strlen(tmp)=82
strlen(tmp)=86
strlen(tmp)=86
strlen(tmp)=90
strlen(tmp)=90
[..]
strlen(tmp)=1266
strlen(tmp)=1266
strlen(tmp)=1270
strlen(tmp)=1270
strlen(tmp)=1274
strlen(tmp)=1274
strlen(tmp)=1278
strlen(tmp)=1278
strlen(tmp)=1282
strlen(tmp)=1282
strlen(tmp)=1286
strlen(tmp)=1286

es will mir nicht in den kopf..scheint mir ein unlogisches verhalten fuer einen computer.

rüdiger

ähm, ich versteh dein Problem nicht. Die größe ist doch immer gleich vor und nach dem Aufruf von malloc.

btw. ist deine Funktion extrem ineffizient. Du machst nicht nur teure überflüssige Funktionen (memset) auch solltest du lieber memcpy anstelle von strcpy benutzen, wenn du die Länge des Strings kennst, da memcpy ja nach dem besser optimiert sein kann (bitblast)

danke fuer die kritik, ich werds mir merken. wenn du sonst eine idee hast, wie ich das optimieren koennte, sags bitte.
//

aber die groesse des buffers ist nicht immer gleich. beim ersten beitrag steht bei der ausgabe des programms:

strlen(tmp)=12
strlen(tmp)=13

da ist der buffer vorher und nachher nicht gleich gross.

und wenn ich immer 4 bytes dazu allokiere, sollte doch die groesse des end buffers immer durch 4 teilbar sein, oder nicht? im zweiten beitrag sieht man, springt die groesse von 72 auf 78, was einen unterschied von 6 ergibt.

ich hoffe es ist nun etwas verstaendlicher..

rüdiger

das liegt daran, dass du zuwenig Speicher reservierst. strlen liefert die Anzahl der Zeichen zurück ohne das 0-Terminierungszeichen. strcpy kopiert das Zeichen aber mit. Also theoretisch ein Bufferoverflow.

Zur Optimierung: Ich würde hier lieber realloc verwenden. Also das hin und her zu kopieren.

aber warum passiert das nur dieses eine mal und sonst nie? in allen anderen faellen gibt strlen 2 mal die gleiche laenge zurueck.
und ob ich strcpy oder memcpy brauche, hat auf die ausgabe des programms keinen einfluss.

ich probier mal eine loesung mit realloc, scheint mir in der tat schoener.

danke

rüdiger

dass das eben nur einmal passiert ist reiner Zufall. Deswegen sollte man undefined behaviour vermeiden

es funktioniert mit realloc! vorerst jedenfalls..sonst komme ich wieder.
danke fuer die hilfe!