ich hoffe mir kann jmd. helfen.

Ich soll eine Struktur Kunde erstellen mit einer nr (int), einem betrag (float) und einem namen (Zeiger auf C-String).
Beim Kopieren von Kundendaten sollen einfach zwei Zeiger auf diese Struktur übergeben werden.
Dabei ist jedoch ggf. ein bereits existierender C-String zu löschen und ein neuer passender Länge zu allokieren.

Funktioniert jedoch irgendwie nicht bei mir.

Ich glaube meine Fehler liegen beim setzten bzw. löschen des C-Strings. Irgendwas will da noch nicht wie ich will.

Beim ausführen kommt immer "unbehandelte Ausnahme bei x0.... Zugriffsverletzung beim lesen an Position 0x000..

struct neuKunde
{
	int knr;
	float betrag;
	char *name;
};

void initneuKunde(neuKunde *k);
void copyneuKunde(const neuKunde *von, neuKunde *nach);
void deleteneuKunde(neuKunde *k);
void setneuKunde(int knr, float betrag, char *name, neuKunde *k);

void initneuKunde(neuKunde *k)
{
	k->betrag = 0.0;
	k->knr = 0;
	k->name = NULL;
}
void copyneuKunde(const neuKunde *von, neuKunde *nach)
{
	if( nach->name != NULL )
	{
		delete [] nach->name;
		nach->name = NULL;
	}
	nach->name = new char[strlen(von->name)];
	strcpy(nach->name, von->name);
	nach->knr = von->knr;
	nach->betrag = von->betrag;
}
void print(neuKunde *k)
{
	cout << k->betrag << "  " << k->knr << "  " << k->name << endl;
}
void deleteneuKunde(neuKunde *k)
{
		k->betrag = 0.0;
		k->knr = 0;
		delete [] k->name;
}
void setneuKunde(int knr, float betrag, char *name, neuKunde *k)
{
	k->knr = knr;
	k->betrag = betrag;
	if( k->name != NULL )
	{
		delete [] k->name;
		*k->name = NULL;
	}
	strcpy(k->name, name);
}

int main()
{
	neuKunde *k = new neuKunde();
	initneuKunde(k);
	neuKunde *kk = new neuKunde();
	initneuKunde(kk);
	copyneuKunde(k,kk);
	cout << "neu";
	print(kk);
	cout << "delete alt -> neu nochmal";
	delete k;
	print(kk);
}

cout << k->betrag << " " << k->knr ;
if(k->name != NULL)
    cout << " " << k->name;
cout << endl;

In Copy fehlen auch noch Abfragen auf NULL.

nach->name = new char[strlen(von->name)];

funktioniert nicht wenn von->name = NULL ist.

Muss das dann also so aussehen (copy)

void copyneuKunde(const neuKunde *von, neuKunde *nach)
{
    if( nach->name != NULL )
    {
        delete [] nach->name;
        nach->name = NULL;
        nach->name = new char[strlen(von->name)];
    }
    //nach->name = new char[strlen(von->name)];
    strcpy(nach->name, von->name);
    nach->knr = von->knr;
    nach->betrag = von->betrag;
}

if(von->name != NULL)
	{
		nach->name = new char[strlen(von->name)]; //eventuell fehlt hier noch +1 wegen '/0'
		strcpy(nach->name, von->name);
	}
	else
	{
		nach->name = new char[100];
		nach->name = "test";
	}

void copyneuKunde(const neuKunde *von, neuKunde *nach)
{
    if( nach->name != NULL )
    {
        delete [] nach->name;
        nach->name = NULL;
    }
    nach->name = new char[strlen(von->name)];
    strcpy(nach->name, von->name);
    nach->knr = von->knr;
    nach->betrag = von->betrag;
}

So wie ich das verstehe, wird ja bei init der Zeiger bzw. der C-String auf NULL gesetzt.
Dann bei copyneuKunde wird geprüft, ist der Zeiger NICHT NULL, also muss was drin stehen, dann gibt man den Speicher frei und setzt den Zeiger auf NULL. Ist der Zeiger jedoch schon NULL kann man gleich mit strcpy() den C-String kopieren.

So funktioniert es doch auch oder?
Kann mir das vllt. jemand erklären was ich da falsch programmiert habe..

Edit: Und warum struct, das Ganze ist viel sinnvoller in einer Klasse untergebracht.

Oder vllt. kannst du mir einfach grob erklären.. weil ich versteh das noch nich.

wenn das char array nicht NULL ist... muss man es zuerst löschen und den Zeiger auf NULL setzen.
Aber in deiner copyneuKunde funktion ist gar kein delete etc. drin.
Oder macht das iwas anderes von alleine oder... ?!

Oder das hier:

void setneuKunde(int knr, float betrag, char *name, neuKunde *k)
{
	k->knr = knr;
	k->betrag = betrag;

	if( k->name != NULL )
	{
		delete [] k->name;
		*k->name = NULL;
	}

	strcpy(k->name, name);
}

Funktioniert auch nicht, bestimmt wegen dem Delete!?
Aber wir sollen den Speicher aufräumen und neu allokieren usw.
Ich glaube das is hier das Problem.

void copyneuKunde(const neuKunde *von, neuKunde *nach) 
{ 
    if( nach->name != NULL ) 
    { 
        delete [] nach->name; 
        nach->name = NULL; 
    }

	if(von->name != NULL)
	{
		nach->name = new char[strlen(von->name + 1)]; 
		strcpy(nach->name, von->name);
	}
	else
	{
		nach->name = new char[100];
		nach->name = "test";
	}

    nach->knr = von->knr; 
    nach->betrag = von->betrag; 
}

Edit: Bei deiner letzten Funktion fehlt wieder das new!

Habs jetzt so.
Funktioniert jetzt eigentlich auch soweit.

Kann ich irgendwie prüfen, ob der Speicher auf wirklich freigegeben wurde wenn ich mittels deleteneuKunde() einen Kunden lösche?

void setneuKunde(int knr, float betrag, char *name, neuKunde *k)
{
	if(k->name != NULL)
	{
		delete [] k->name;
		k->name = NULL;
	}
	k->name = new char[strlen(name)+1];
	strcpy(k->name,name);
	k->knr = knr;
	k->betrag = betrag;
}

void copyneuKunde(const neuKunde *von, neuKunde *nach)
{
    if( nach->name != NULL )
    {
        delete [] nach->name;
        nach->name = NULL;
    }

    if(von->name != NULL)
    {
        nach->name = new char[strlen(von->name + 1)];
        strcpy(nach->name, von->name);
    }
    else
    {
        nach->name = new char[100];
        nach->name = "test";
    }

    nach->knr = von->knr;
    nach->betrag = von->betrag;
}

void deleteneuKunde(neuKunde *k)
{
		k->betrag = 0.0;
		k->knr = 0;
		delete [] k->name;
		*k->name = NULL;
}

Danke, funktioniert so.

Ich denk mal das funktioniert auch richtig das er den Speicher löscht usw... !?

Danke dir !! :xmas1:

void setneuKunde(int knr, float betrag, char *name, neuKunde *k)
{
    if( k != NULL )
    {
        k->knr = knr;
        k->betrag = betrag;
        if( k->name != NULL )
        {
            delete [] k->name;
            *k->name = NULL;
        }
        strcpy(k->name, name);
    }
}

Und wenn NULL übergeben wird.. dann wird halt gar nichts gemacht.. gibt ja dann nichts zum setten...

Ist das wirklich sinnvoll? Gibt es Situationen, in denen der Benutzer NULL übergibt, um nichts zu tun?

Ich habe eher das Gefühl, du willst damit Fehler vermeiden, die durch Nullzeiger-Dereferenzierung entstehen. Tatsächlich erreichst du aber das Gegenteil: Wenn NULL als Parameter zulässig ist und einfach nichts passiert, können sich Logikfehler einschleichen. Denn du merkst nicht unmittelbar, dass ein gewünschter Aufruf keinen Effekt hat. Zudem verleitet diese Semantik dazu, es im Anwendercode mit Nullzeigern ebenfalls nicht so genau zu nehmen.

Und dabei haben wir die Tatsache gar noch nicht berücksichtigt, dass die vielen If-Abfragen den Code unnötig hässlich machen.

Deshalb: Gültigkeit des Zeiger als Precondition voraussetzen. Damit du solche Fehler gleich bemerkst, kannst du Assertions einsetzen:

void setneuKunde(int knr, float betrag, char *name, neuKunde *k)
{
    assert( k != NULL );
    // Restlicher Code (ohne if) wie bisher
}

Damit du mit dieser Aussage auch was anfangen kannst, hier ein paar Verbesserungsvorschläge. Ich verstehe, falls du gewisse Dinge hiervon noch nicht kennst, aber du könntest dir diese für später merken oder wieder einmal zu diesem Thread zurückkehren. Denn es handelt sich um Punkte, die in C++ zu den essentiellen Grundlagen gehören.

• Verwende Code wieder. Innerhalb copyneuKunde kannst du zum Beispiel deleteneuKunde aufrufen, um den Zielkunden zu überschreiben.
• Klassen sind unter Anderem gerade dazu da, externe Funktionen zur Implementierung trivialer Funktionalität wie dem Kopieren eines Objekts zu vermeiden. Du wirst sicher noch was von Konstruktor, Kopierkonstruktor, Zuweisungsoperator und Destruktor hören.
• Grundsätzlich wird in modernem C++ manuelle Speicherverwaltung vermieden, wo es nur geht, und durch Konzepte wie RAII abgelöst. Auch die Zeichenkettenverwaltung mit C-Strings ist inhärent fehleranfälig und unkonfortabel. In C++ gäbe es dafür std::string .
• Dazu gibts noch kleinere Fehler, die mit dem gerade erwähnten Punkt zusammenhängen. Zum einen hast du bei

delete [] k->name; 
*k->name = NULL;

eine Dereferenzierung zu viel, zum anderen darfst du nicht mit

strcpy(k->name, name);

in einen Nullzeiger kopieren. Und hier

nach->name = new char[100];
nach->name = "test";

hast du ein Memory Leak, weil du gleich nach->name überschreibst.

Was mich hingegen eher erstaunt, ist, dass du bereits Const-Correctness (bei copyneuKunde() ) richtig anwendest. Das beachten viele Leute, die C++ lernen, eher spät.