Ich habe mir eine Funktion gebastelt, die einen String in einen anderen einfügen kann - das funktioniert prächtig - doch stoße dabei auf ein Problem. Hier mal kurz zur Veranschaulichung ein geeignetes Code-Beispiel:

extern char* weldstr(int ascii); //Deklaration

char* somestr(int ascii) { //Definition
   *char c = (char*)malloc(sizeof(char)*2);
   *char = ascii;
   *(char+1) = '\0';
   return c;
}

//Irgendwo anders im code wird die Funktion somestr aufgerufen:
char das_a[2];
// Gib mir ein 'A'!
strcpy(das_a, somestr(65)); //65 = ASCII-Dezimalzahl für 'A'

Das Problem: Der mit malloc() angeforderte Speicher wird nicht wieder freigegeben.
Das richtige Problem: Mir fällt kein Weg ein wie man das Problem SCHÖN lösen kann. Ich könnte nun eine globale Variable machen, die sich den Pointer für mich merkt, und nach dem Aufruf von somestr() diesen freeen mit free(). Das unschöne daran ist, dass ich dann jedes mal manuell freeen müsste. Da frag ich mich, ob man das nicht besser irgendwie irgendwo verbauen kann. Unmittelbar vor dem return ist nämlich leider zu früh, wie ich feststellen musste. Der char* war schon nicht mehr der selbe. Ideen? :o

Danke im Vorraus,

Silencer.

extern char* weldstr(int ascii); //Deklaration

char* somestr(int ascii) { //Definition
   *char c = (char*)malloc(sizeof(char)*2);
   *c = ascii; //Hier stand char statt c
   *(c+1) = '\0'; //Hier auch xD
   return c;
}

//Irgendwo anders im code wird die Funktion somestr aufgerufen:
char das_a[2];
// Gib mir ein 'A'!
strcpy(das_a, somestr(65)); //65 = ASCII-Dezimalzahl für 'A'

char* create_string(char ascii)
{
	static char buf[2];

	buf[0] = ascii;
	buf[1] = '\0';

	return buf;
}

error C2057: expected constant expression
error C2466: cannot allocate an array of constant size 0
error C2133: 'newStr' : unknown size
warning C4172: returning address of local variable or temporary

Frag mich nicht wie er auf 0 kommt. Hier mal das ganze mit Array statt pointer.

//Inserts one string into another for a length of maxNewLen chars at position
//insAtPos. If overwrite is true, inserted String will overwrite source string
//from position insAtPos onwards.
const char* strins(const char* srcStr, const int maxNewLen, const char* insStr, const int insAtPos, const bool overwrite) {
	//srcStr is the string in which we want to insert another string
	//maxNewLen is the maximum length in chars of the resulting string
	//insStr is the string to be inserted
	//insAtPos indicates the position where to insert insStr into srcStr
	//overwrite indicates whether to actually insert into or to overwrite srcStr at/from insAtPos with insStr
	char newStr[maxNewLen+1]; //Create newStr to deposit new string in
	int newCurPos = 0; //Counter for position
	int srcCurPos = 0; //Counter for position
	int insCurPos = 0; //Counter for position
	int srcLen = (int)strlen(srcStr); //Amount of chars before '\0'
	int insLen = (int)strlen(insStr); //Amount of chars before '\0'
	while(newCurPos < maxNewLen) { //While not exceeding maxNewLen
		if(newCurPos < insAtPos && srcCurPos < srcLen) { //If we are before the position to insert string at AND the source string has not already copied entirely
			newStr[newCurPos] = *(srcStr+srcCurPos); //Copy the char from/to current position
			       newCurPos++;          srcCurPos++; //Increase positions by one
		} else { //Else
			if(newCurPos < insAtPos - 1) { //If there is a gap of over 0 '\0's between current position of the new string and the position where to insert insStr
				return newStr; //Return the string as far as it has been processed (should not randomly fill the gap)
			}
			break; //Exit the while-loop
		}
	}
	while(newCurPos < maxNewLen) { //Enter while-loop with same condition (doing this to workaround predictable if-checks in previous loop -> increase algorithm speed)
		if(insCurPos < insLen) { //If insStr has unprocessed chars
			newStr[newCurPos] = *(insStr+insCurPos); //Copy them into newStr
			       newCurPos++;          insCurPos++; //Increase positions by one
			if(overwrite) srcCurPos++; //If srcStr shall be overwritten, increase srcCurPos to skip the corresponding char
		} else { //Else
			if(srcCurPos < srcLen) { //If srcStr has unprocessed chars
				newStr[newCurPos] = *(srcStr+srcCurPos); //Copy them into newStr
				       newCurPos++;          srcCurPos++; //Increase positions by one
			} else { //Else
				break; //Exit the while-loop
			}
		}
	}
	newStr[newCurPos] = '\0'; //Add null-terminator
	return newStr; //Return the fully processed, new string
}

...

Ich wollte grad ins Bett... Das geht jetz nich, weil ich nach dem Post Code-Alpträume bekomme.

//Inserts one string into another for a length of maxNewLen chars at position
//insAtPos. If overwrite is true, inserted String will overwrite source string
//from position insPos onwards.
const char* strins(const char* srcStr, const int maxNewLen, const char* insStr, const int insAtPos, const bool overwrite) {
	//srcStr is the string in which we want to insert another string
	//maxNewLen is the maximum length in chars of the resulting string
	//insStr is the string to be inserted
	//insAtPos indicates the position where to insert insStr into srcStr
	//overwrite indicates whether to actually insert into or to overwrite srcStr at/from insAtPos with insStr
	//char* newStr = (char*)malloc(sizeof(char)*(maxNewLen+1)); //Allocate sufficient memory
	if(maxNewLen >= MAX_KEY)
		return 0;
	char* newStr = new char[MAX_KEY];
	int newCurPos = 0; //Counter for position
	int srcCurPos = 0; //Counter for position
	int insCurPos = 0; //Counter for position
	int srcLen = (int)strlen(srcStr); //Amount of chars before '\0'
	int insLen = (int)strlen(insStr); //Amount of chars before '\0'
	while(newCurPos < maxNewLen) { //While not exceeding maxNewLen
		if(newCurPos < insAtPos && srcCurPos < srcLen) { //If we are before the position to insert string at AND the source string has not already copied entirely
			*(newStr+newCurPos) = *(srcStr+srcCurPos); //Copy the char from/to current position
			         newCurPos++;          srcCurPos++; //Increase positions by one
		} else { //Else
			if(newCurPos < insAtPos - 1) { //If there is a gap of over 0 '\0's between current position of the new string and the position where to insert insStr
				return newStr; //Return the string as far as it has been processed (should not randomly fill the gap)
			}
			break; //Exit the while loop
		}
	}
	while(newCurPos < maxNewLen) { //Enter while-loop with same condition (doing this to workaround predictable if-checks in previous loop -> increase algorithm speed)
		if(insCurPos < insLen) { //If insStr has unprocessed chars
			*(newStr+newCurPos) = *(insStr+insCurPos); //Copy them into newStr
					 newCurPos++;          insCurPos++; //Increase positions by one
			if(overwrite) srcCurPos++; //If srcStr shall be overwritten, increase srcCurPos to skip the corresponding char
		} else { //Else
			if(srcCurPos < srcLen) { //If srcStr has unprocessed chars
				*(newStr+newCurPos) = *(srcStr+srcCurPos); //Copy them into newStr
				         newCurPos++;          srcCurPos++; //Increase positions by one
			} else { //Else
				break; //Exit the while-loop
			}
		}
	}
	*(newStr+newCurPos) = '\0'; //Add null-terminator
	return newStr; //Return the fully processed, new string
}

Silencer4252 schrieb:

extern char* weldstr(int ascii); //Deklaration

char* somestr(int ascii) { //Definition
   *char c = (char*)malloc(sizeof(char)*2);
   *c = ascii; //Hier stand char statt c
   *(c+1) = '\0'; //Hier auch xD
   return c;
}

//Irgendwo anders im code wird die Funktion somestr aufgerufen:
char das_a[2];
// Gib mir ein 'A'!
strcpy(das_a, somestr(65)); //65 = ASCII-Dezimalzahl für 'A'

Du willst den Speicherplatz wieder freigeben. Warum machst du das nicht direkt nach deinem Funtkionsaufruf?

// Irgendwo anders im code...
char* tmp_ptr = somestr(65);
strcpy(das_a, tmp_ptr);
free (tmp_ptr);

Außerdem verstehe ich auch nicht, warum du nicht Chriffre's Lösung nimmst, was ist daran auszusetzen?

Grüße

Soll dir jetzt jemand die Geschichte von std::string, auto_ptr und/oder RAII erzählen (C++) oder willst du doch eher nach ANSI C verschoben werden?

Silencer4252 schrieb:

Tuh was du für richtig hälst. |:cX
(verschieb mich eben ^^)

Das waren gute Hinweise, die erneut_ gebracht hat. Recherchiere nach Kapselung, std::string und RAII. Da werden Sie geholfen.

Selbst in C kapselt man die Speicherverwaltung für dynamische Zeichenketten und hantiert nicht direkt mit char* herum. Der Unterschied ist nur, dass sich eine solche Kapselung in C jeder selbst bastelt während es sie in C++ schon vorgefertigt gibt: std::string .

Gruß,
SP

Das Beispiel war in so fern blöd, weil in diesem die array-Größe bekannt ist.
Im Fall von strins() ist das ja nicht so, es sei denn man gibt ein absolutes
maximum der Länge der Zeichenkette vor - schön ist das aber auch nicht.

Natürlich kann ich das freeen direkt nach dem Funktionsaufruf machen, aber diese
Lösung ist in so fern unpraktisch, dass man dann bei häufigen Aufrufen von strins()
oder was auch immer für einer Funktion immer und immer wieder "manuell" den pointer
freeen muss.

Ich informier mich mal wegen Kapselunf, std::string und RAII. Danke. :o