Hab mir mal (im Rahmen meines Projektes) gedacht ich schreibe ein eigenes strcpy weil ich da so einiges ausschießen könnte ... so wie Leerzeichen in der Eingabe und so...

mein strcpy bis jetzt :

+
void my_strcpy(char * dest, const char * source)   
{
	int i = 0;
	while ( source[i] != '\0' )
	{
		dest[i] = source[i];
		i++;

	}

	return berechne[dest];  // gibts noch nen konflikt...
}

und wöchentlich grüßt das Murmeltier... oder auch ich

gruß

void my_strcpy(char * dest, const char * source)   
{
	int i = 0;
	do
	{
		dest[i] = source[i];
		i++;

	}
        while ( source[i] != '\0' );

	return berechne[dest];  // gibts noch nen konflikt...
}

bin gerade am überlegen ob man nicht klugerweise die Leerzeichen bei einer Eingabe in der FUnkiont direkt "nicht mitkopiert" also das wenn einer

2 (2 +2) eingibt daraus 2(2+2) wird

wie überprüfe ich denn in C++ ein Leerzeichen?

if (source[i] == '') ?

...

void strcpy(char* dest, const char* src)
{
   do {
      *dest++ = *src;
   } while (*src++);
}

PS:

source[i]  == ' '

Ein Leerzeichen ist ' '

void my_strcpy(char * dest, const char * source)   
{
	int i = 0;
	do
	{
		dest[i] = source[i];
		if (source[i] == ' ')
		{
			dest[i] = source[i+1];
			i++;
		} 
	} while (source[i] != '\0' );

	return berechne[dest]; //ungültiger index, Dereferenzierung nicht zulässig   ???
}

mh das Löschen bei Leer ist noch nicht richtig bin noch dran aber trotzdem 2 Frage:

was bedeutet die Fehlermeldung beim Return... versteh ich nicht...
(hintergrund: die Bearbeitete Eingabe soll wieder zurück an meine Funktion Berechne (wo sie herkommt) geschickt werden...

Das löschen der Leerzeilen... könnte da bestimmt hilfe gebrauchen

#include <string>
#include <algorithm>

bool isBlank(char c) //alternativn sind moeglich.
{
    return c == ' ';
}

//...
std::string str1 = "Hallo Du schoene Welt";
std::string str2;

std::back_insert_iterator<std::string> inserter(str2);

std::remove_copy_if(str1.begin(), str1.end(), inserter, isBlank);
//str2 ist eine Kopie von str1 ohne Leerzeichen.

Oder flexibler:

struct Remover
{
    Remover(char charToRemove)
        : m_charToRemove(charToRemove)
    { }

    bool operator()(char c)
    {   return c == m_charToRemove; }

    char m_charToRemove;
};
//...
//Rest wie vorher
std::remove_copy_if(str1.begin(), str1.end(), inserter, Remover(' '));

std::remove_copy_if(str1.begin(), str1.end(), inserter, bind2nd(equal_to<char>(), ' '));

Und übrigens noch zwei Sachen:
1. die struct Variante ist der Funktion vorzuziehen
2. die struct sollte von std::unary_function oder std::binary_function abgeleitet werden, damit man auch noch so etwas wie std::not1 oder std::not2 or whatever else auf das Prädikat anwenden kann.

halt mit Char Array und ohne std:: befehlen und so... ihr wisst wie ich es meine

auch dazu einen Lösungs ansatz da?

// strcopy ( dest, source )
void my_strcpy(char * dest, const char * source)   
{
	int i = 0;
	int j = 0;
	do
	{
		dest[i] = source[i];
		if (source[i] == ' ')
		{
			dest[i] = sizeof(source[i]);
		} 
		i++;
		j++;
	} while (source[i] != '\0' );

	return berechne[dest]; //ungültiger index, Dereferenzierung nicht zulässig   ???

Nur das es bei mir jetzt noch nicht ganz richtig ist... ihr seht wohl warum XD

return berechne[dest]; //ungültiger index, Dereferenzierung nicht zulässig ???

was heißt das? wie muss ich das umschrieben das ich es wieder in die Funktion berechne kriege.

würd mir mehr helfen momentan

Mahlzeit

und deine fkt hat keinen rückgabetyp (void) - wieso dann ein return xyz; ?

was willst du mit dieser zeile bezwecken:
dest[i] = sizeof(source[i]);

dann hast du statt dem leerzeichen dort halt nen zeichen drin, was dich noch viel mehr stört?!

außerdem wäre die arbeit mit zeigern vermutlich sehr viel schneller (obwohl man das wohl prüfen müsste und ich mir durchaus vorstellen kann, dass der compiler die laufvariablen schon weglassen wird und das ganze durch pointer ersetzen wird...

meine strcpy fkt würde am anfang noch überprüfen, ob man zufällig nullptr übergeben hat (auch wenns nur nen assert ist, es wäre drin ^^)

bb

char * my_strcpy(char * dest, const char * source)
{
	size_t i = 0;
	do
	{
		dest[i] = source[i];
		++i;
	}
	while (source[i] != '\0');
	return dest;
}

Deine Implementierung ist also schon iO. Du solltest lediglich darauf achten, size_t zu verwenden, nicht int.

Auf Implementationen wie

void my_strcpy (char* dest, char const* src)
{
   while (*dest++ = *src++) ;
}

nur der Kürze wegen, solltest du verzichten. Erstens ist das wenig ausdrucksstark. Und zweitens wird gerade in technischen Dokumentationen zu Mikroarchitekturen nicht selten auf die Verwendung von Indexierung statt Dereferenzierung hingewiesen. Auch wenn in vielen Fällen aufgrund der Optimierungen des Compilers keine Unterschiede entstehen.

Was du mit

dest[i] = source[i];
		if (source[i] == ' ')
		{
			dest[i] = sizeof(source[i]);
		}

vorhast, ist mir momentan noch unklar. sizeof liefert einen Grössenwert vom Typ size_t. Es macht also keinen Sinn, das einem einzelnen Zeichen zuzuweisen. Falls du Leerzeichen einfach ersetzen willst, zB mit einem Unterstrich, dann wäre folgendes eine gute Lösung

dest[i] = source[i] == ' ' ? '_' : source[i];

Auch hier wieder eine gute Hilfestellung für den Compiler. Verwende bedingte Anweisungen statt Verzweigungen.

return berechne[dest]; //ungültiger index, Dereferenzierung nicht zulässig   ???

Dazu lässt sich nicht viel sagen. Was ist denn berechne? Und was soll es bezwecken?

jetzt soll aber in der my_strcpy direkt, sollte ein Leerzeichen eingegeben werden der restliche Term dorthin verschoben werden.

also:

2 +2(2* 2)
2+2(2* 2)
2+2(2*2) <- DAS wird dann wieder in meine Funktion Berechne geschickt (soll jedenfals)

Berechne macht dann so sachen wie Klammern weg und den Term Parsen ... nur muss es halt ersteinmal korrekt reingeschickt werden weil er 2 +2(2* 2) nicht macht also 0 ausgibt.

Lediglich DAS ist noch mein Problem...

In einen string packen, Leerzeichen löschen und Fertig. Wo ist das Problem?

Das ich es nicht mit Strings mache...

du meinst bestimmt so das vorgehen mit std:str ... irgendwas bla...

zum Beispiel habe ich Klammernwegmachen auch anders lösen müssen:

//Wenn Außen Klammern werden diese zur weiteren Berechnung entfernt   Karsten Menger Computer Future Solution
	//(Klammern wenn: [0] != '(' und [letzte Position - 1] != ')' 
	if (term[0] == '(' && term[strlen(term)-1]  == ')' )
	{
		strncpy (wterm, term+1, term[strlen(term)-2]);
			//oder:		std::memmove(wterm, term+1, term[strlen(term)-2]);
		wterm[strlen(wterm)-1] = 0;
		return berechne (wterm);
	}

kleiner Programmausschnitt... so mach ich das halt erstmal... ( zum üben )

drakon schrieb:

In einen string packen, Leerzeichen löschen und Fertig. Wo ist das Problem?

kleiner Programmausschnitt... so mach ich das halt erstmal... ( zum üben )

Das Problem ist, dass wenn du es erstmal am Anfang immer so machst, du es später genauso machen wirst.

Und dieses Vorgehen birgt im Vergleich zu einer Benutzung von std::string viele, viele Gefahren..

Aber wenn du wirklich vorwärts kommen willst, dann benutz std::string und die Standardalgorithmen. Wenn du wissen willst, wie die das gemacht haben, dann kannst du auch noch den Source anschauen.

Virokams schrieb:

Das Problem ist, dass wenn du es erstmal am Anfang immer so machst, du es später genauso machen wirst.

Und dieses Vorgehen birgt im Vergleich zu einer Benutzung von std::string viele, viele Gefahren..

stimmt... aber ist wie gesagt anweisung von oben das ich es erstmal so mache... ich denke danach werde ich es wohl nochmal mit Strings lösen.

tut mir ja auch leid

char * my_strcpy(char* dest, const char * source)
{
int j = 0;
for (int i = 0; source[i] == '\0' ;i++)
{
	if(source[i] != ' ')
	{
		dest[j++] = source[i];
	}
}
dest[j] = '\0';
return dest;
}

obwohl es noch nicht wirklich geht wenn ich in meinem Programmcode anstelle strcpy my_strcpy nutze hmmmmm... sieht aber mehr als korrekt aus XD

Habe es jetzt erstmal SO gelöst:

for (int i = 0; source[i] == '\0' ;i++)
{
	if(source[i] != ' ')
	{
		dest[j++] = source[i];
	}
}

Abbruch Bedingungen sind in C++ Zählschleifen so, dass die Schleife abgebrochen wird, wenn die Bedingung nichtmehr erfüllt ist.

source[i] != '\0'

Das sollte funktionieren.

Grüße,
Daniel

source[i] != '\0'

meeeensch ... schriebfehler...

okey jetzt macht er keine Fehler mehr... jedoch löscht er die Leerzeichen noch nicht... liegt aber nicht an der Funktion my_strcpy sondern eher das irgendwo in meinem Programm schon geparst wird obwohl der Term noch nicht korrekt vorbereitet wurde sprich () aussen weg und halt die Leerzeichen weg... muss ich noch schauen...

obwohl es noch nicht wirklich geht wenn ich in meinem Programmcode anstelle strcpy my_strcpy nutze hmmmmm... sieht aber mehr als korrekt aus XD

Das beste wäre wohl, du würdest auf beide verzichten, zumindest in C++.

In der C++-Standardbibliothek gibt es nämlich die Klasse std::string , die komfortable Zeichenkettenverwaltung erlaubt. Schau doch mal auf www.cplusplus.com nach.