Ich habe eine Vorlage, soll einen char*-String in einer Funktion verändern. Vorgegeben ist, dass sie constant ist.

Ich dachte mir dabei, konstante kann und sollte man net ändern. Also hab ich das wie folgt gelöst.

int main()
{
...

const char* bla = "hallo";
aendere(bla);
...

}

(eine Funktion soll das ding verändern, die sieht so aus;)

void aendere( const char*& original)
{
char* copy = 0;
copy = new char[strlen(original)];  
strcpy(copy, original);

... weitere Änderungen an copy ...

original = copy;

}

Wichtig zu wissen ist, dass nur einzelne Elemente des Strings geändert werden, die länge verändert sich nicht. Jetzt ist mir natürlich klar, dass es ein Memory-Leak gibt. Habt ihr also eine andere Möglichkeit, den const char*-String zu verändern? Danke!

Ich dachte mir dabei, konstante kann und sollte man net ändern

Da stimmt aber irgendwas nicht.
Es ist UB (und damit "verboten"), ein String-Literal im Speicher zu verändern, das weißt du ja bereits.

Vorgegeben ist, dass sie constant ist.

"sie"?

• Meinst du die Funktion?
  cv-qualifier können nur einige Member-Funktionen haben.
• Bezieht sich "sie" aber auf den String, dann ist das erstens falsche Grammatik und außerdem widerspricht sich das mit dem ersten Satz der Aufgabendefinition (es soll ein Zeiger vom Typ char* sein).

Irgendwie habe ich das Gefühl, entweder du hast die Aufgabe falsch zitiert (bzw. wiedergegeben) oder derjenige der sie verfasst hat hat keine Ahnung von Const-Correctness.
Deswegen schließe ich mich SeppJ an und sage:

SeppJ schrieb:

Nenn mal die genaue Aufgabenstellung.

Also Vorgabe:

const char* beispiel="bla bla bla";

also constanter inhalt, variabler zeiger. (Mit "Sie" meinte ich den String, kommt da immer durcheinander. Er ist konstant)

Aufgabe: Funktion soll den String verändern, so dass bla bla. Es werden Zeichen ausgetauscht.

Ich hab es so gelöst, dass, wie oben zu stehen, eine Kopie des Inhaltes angelegt wird, der dann verändert wird und der alte Zeiger dann auf den neuen Inhalt umgelenkt wird. So erreicht man mit dem selben "const char* beispiel" nun einen neuen Inhalt.

Das Problem ist, dass der alte Inhalt noch irgendwo im Speicher rumgammelt. Das ist bei dem Programm net schlimm, es geht aber um eine art Test. Meine Lösung ist schon weg, aber ich bin immer noch am überlegen.

Nun habe ich im Internet cast_const<...>() gefunden, das soll wohl funktionieren. Aber wenn ich damit den Typ con const char* auf char* ändere, lässt er mich trotzdem nicht den Inhalt ändern. (Compiler sagt, dass "beispiel[5]" nicht beschreibbar ist. Auch sagen viele, dass man sowas nicht machen sollte. (Konstant heißt nicht ohne Grund so,..)

Meine Fragen; funktioniert es irgendwie (z.B. mit cast_const?)
man sagt immer, es können unvorhersehbare Probleme auftreten, ist das wirklich der Fall?

Wenn du const char* beispiel="bla bla bla"; hast, kannst du Beispiel nicht löschen und brauchst es nicht tun. Da gammelt nichts im Speicher rum.

Also musst du ihn beschreibbar machen. Das geht zB mit strncpy . Sobald du diesen char* hast, kannst du ihn verändern und musst ihn wieder löschen.

Musst du wirklich beispiel umändern, dann kann das so aussehen:

const char* beispiel="bla bla bla";
int n = strlen(beispiel)+1;
char *beschreibbar = malloc(n);
strncpy(beschreibbar, beispiel, n);
aendere(beschreibbar); // ändere nimmt einen char* entgegen
beispiel = beschreibbar; // höhö
free(breschreibbar);

So jedenfalls in C. In C++ würde man strings verwenden und dann erübrigt sich das Problem.

const char* beispiel = "bla bla";

ja quasi ist. Dann dümpelt das net im Speicher rum, nachdem der Zeiger umgelenkt wurde?

Dann dümpelt das net im Speicher rum, nachdem der Zeiger umgelenkt wurde?

Schon, aber nicht so wie du meinst. Das ist ein fester Teil deiner Executable und der Zeiger zeigt eben auf eine bestimmte Stelle in deinem Programmcode. Den eigentlichen Inhalt dieser Speicherstelle kannst du (in der Regel) nicht verändern und das ist auch gut so und ganz normal und du brauchst dir deswegen keine Sorgen zu machen.
Mehr Sorgen machen würde ich mir wegen der Aufgabe, ich kann mir eigentlich nur vorstellen, dass du die falsch verstanden hast. Ansonsten würde das nämlich heißen, dass der Aufgabensteller keine Ahnung hat oder euch komische Sachen beibringt. Da wir alle wissen, wie extrem kompetent in C++ Lehrer sind, die vor 40 Jahren mal Basic gelernt haben, kann ich mir das wirklich nicht vorstellen .

In dem Vorgegebenen Code ist eben so eine Zeile:

"const char *bla = "quarks und Co.";

wobei char* bla das selbe ist wie char *bla, nach meinem Wissen.

Eine Aufgabe ist quasi: Die Funktion ... soll in dem String "bla" alle "u" durch "U" ersetzen (u -> U). (Blödes BEispiel aber ich weiß net, ob ich so einfach die Aufgabe und die Firma hier posten sollte... )

Eine Aufgabe ist quasi: Die Funktion ... soll in dem String "bla" alle "u" durch "U" ersetzen (u -> U).

Bitte sag deiner Firma, das Assessment Center soll sich bessere Aufgaben ausdenken. Die Aufgabe ist bescheuert formuliert und auch komisch, denn die Funktion ... sollte nicht einfach einen bestimmten String bearbeiten (können), sondern wenigstens alle.
Funktionen müssen schön allgemein gehalten werden.

Die Funtktion kann alle Strings, die ihr übergeben werden (const char*) bearbeiten. Mir fällt nur gerade ein, dass kein delete[]-Befehl drin ist. Wenn man (nicht in der Aufgabe enthalten) die Funktion über einen mit new angeforderten Speicherplatz laufen lässt, gibt es n Memory-Leak, oder?

In C++ gehen beide Schreibweisen, da gibt es keinen Unterschied. In C ging nur eine.

Nein, das geht auch in C beides.

Die Funtktion kann alle Strings, die ihr übergeben werden (const char*) bearbeiten.

facepalm
Nein, dieser Zeiger impliziert doch dass der String auf den er zeigt nicht verändert werden darf/soll!

Mir fällt nur gerade ein, dass kein delete[]-Befehl drin ist. Wenn man (nicht in der Aufgabe enthalten) die Funktion über einen mit new angeforderten Speicherplatz laufen lässt, gibt es n Memory-Leak, oder?

s. o., den Speicherplatz freizugeben verändert den String insofern dass er jeden Moment überschrieben werden kann. Das darf nicht geschehen. s. o.

Sone schrieb:

In C++ gehen beide Schreibweisen, da gibt es keinen Unterschied. In C ging nur eine.

Nein, das geht auch in C beides.

Wirklich? In C++ von A bis Z steht AFAIK was anderes. Ich krams mal raus, aber ich hab mich bestimmt nur falsch erinnert

Edit: Jup, er sagt nur, dass die eine in C sehr oft genutzt wurde.

Nur gammelt jetzt wirklich ein mit new angelegter Char*-String im Speicher rum. ..

Nur gammelt jetzt wirklich ein mit new angelegter Char*-String im Speicher rum. ..

Vielleicht sollst du auch zeigen, dass du std::string kennst.

wenn ein const char* vorgegeben ist, werde ich doch net anfangen, das ding in ein string umzuwandeln. Ich weiß schließlich net, was man später damit machen will.

Kopf->Tisch
Das war nicht gemeint.

Es ist ein kleiner Teil des Quelltextes schon vorgeschrieben, unter anderem die Deklaration von zwei const char* -Elementen. Dann noch zwei Funktionen ohne Parameterübergabe, die ich füllen soll. Dann noch einen kleinen Dialog ergänzen. Das war es im großen und ganzen.

Ich hab dann halt mitbekommen, das man eigentlich keine const char*-Elemente ändern kann. Die Funktion löst das Problem, indem sie ein neues Element Erzeugt und nach Bearbeitung den alten Zeiger drauf umgelenkt. Schon hat sich das. Die Frage war nur, ob man sich das mit cast_const sparen kann.

Wie wäre euer Ansatz?

Wie wäre euer Ansatz?

Gib uns die genaue Aufgabenstellung, nicht bloß deine prosaische Interpretation. Hast du Code?

P.S.: const_cast ist sicherlich nicht die Lösung, sondern ist grob falsch.

Vorgabe:

class Myclass
{
   public

   ersetze_H_mit_h_(...)
   {
   ...
   }

};

int main()
{
const char* aendermich = "Hallo, hallo"

// Ausgabe neuer und alter String
}

Augabe:
- ersetze_H_mit_h_(...) soll alle "H"s mit "h"s im String aendermich ersetzen.
- bei dem Kommentar // Ausgabe neuer und alter String soll der neue und der alte String ersetzt werden

Da sind noch andere Aufgaben, die hab ich raus gestrichen. Ich hab jetzt alles wichtige von der Formulierung ähnlich gelassen, der Quelltext ist fast identisch, andere Namen...

Was ist an der Lösung inkorrekt? Wenn du Bock hast kannst du dir ja mit std::string::c_str einen const char* geben lassen ...

Geht die Umwandlung von string in c-string schnell? In die andere richtung ja anscheinend schon.

Nach dem was ich verstehe, soll ich "aendermich" verändern und keine neue Variable erzeugen.

Wie kommst du zu diesem Verständnis. Wenn du hinterher die alte Zeichenkette auch noch mit ausgeben sollst, widerspricht dies dieser Interpretation.

P.S.: Eine andere Herangehensweise wäre übrigens, ein "View"-Objekt zu erzeugen, welches gar keine Kopie der Zeichen macht, sondern on-demand eine veränderte Version der Zeichen gibt. Dies würde auch zu der gezeigten Signatur passen, eigentlich fast schon besser. Würde zu einer Firma passen, die starken Wert auf Design-Patterns und so legt.

cout << aendermich;

funktion(aendermich);
cout << aendermich;