"Ändern" eines const char* ??

*Hanns

Danke Bashar, aber das hilft meinen grauen Zellen nciht weiter.

strcopy ( const char* quelle,char* ziel)

ok,
-wie aber veränder ich nun ein einzelnes Zeichen in Ziel?
- und funktioniert dann der Aufruf meiner Funktion , die ein const char* erwartet durch casting ?.i.e

void tuWas ( const char * name){
char * temp;
strcpy ( name, temp);
/** modifiezere Temp ??? */
tuNochwas( (const char*) temp) ;   // das geht ??
}

Ich hab da echte Verständnisprobleme
Danke Hanns

Bashar

dein code:

void tuWas ( const char * name){
  char * temp;
  strcpy ( name, temp);
  /** modifiezere Temp ??? */
  tuNochwas( (const char*) temp) ;   // das geht ??
}

Stop.

1. strcpy erwartet als erstes Argument einen Pointer auf das Ziel und als zweites auf die Quelle. Deine Zeile «strcopy ( const char* quelle,char* ziel)» ist anscheinend frei erfunden. Bitte lies die Dokumentation richtig oder du wirst nie zu programmieren lernen.
2. Angenommen, dein strcpy-Aufruf würde strcpy(temp, name) lauten. Wohin würde strcpy die Zeichen aus «name» kopieren? (Tipp: Alloziere Speicher)
3. eine Funktion, die ein const-Argument erwartet, verspricht damit, dass Argument nicht zu verändern. Das heißt, es ist natürlich kein Problem, ihr einen Zeiger auf nicht-konstante Daten zu übergeben. Umgekehrt gehts nicht, du kannst keine Konstante einer nicht-const Funktion übergeben. Also weg mit dem Cast.

*Hanns

[QUOTE]Original erstellt von Bashar:
[QB]dein code:

void tuWas ( const char * name){
  char * temp;
  strcpy ( name, temp);
  /** modifiezere Temp ??? */
  tuNochwas( (const char*) temp) ;   // das geht ??
}

Stop.

1. strcpy erwartet als erstes Argument einen Pointer auf das Ziel und als zweites auf die Quelle. Deine Zeile «strcopy ( const char* quelle,char* ziel)» ist anscheinend frei erfunden. Bitte lies die Dokumentation richtig oder du wirst nie zu programmieren lernen.

> Stimmt, hier habe ich mich verschrieben !!!
da häte aber der Kompiler angemeckert ( Aber man sollte schon vorher denken )

2. Angenommen, dein strcpy-Aufruf würde strcpy(temp, name) lauten. Wohin würde strcpy die Zeichen aus «name» kopieren? (Tipp: Alloziere Speicher)

> temp ist ein pointer auf char, also müssten die ZEichen aus "name" an der adresse beginnen, auf die temp zeigt ( &temp ) !?

> wenn ich das richtig überlegt habe, müsste ich jetzt
- char* buffer = new char ( mit der länge von "name" + 1) ( wegen chr(0))erzeigen
- den Inhalt von "name" in buffer kopieren ,
- ein 0x0 ins letzte Element setzen, und
- den Inhalt an jeder gewünschten Stelle ( buffer [x]) verändern,
- und buffer als parameter an tuNochwas übergeben ?

3. eine Funktion, die ein const-Argument erwartet, verspricht damit, dass Argument nicht zu verändern. Das heißt, es ist natürlich kein Problem, ihr einen Zeiger auf nicht-konstante Daten zu übergeben. Umgekehrt gehts nicht, du kannst keine Konstante einer nicht-const Funktion übergeben. Also weg mit dem Cast.

> d.h. eine funtion foo ( const char* x ) und fuu ( char* x) hätten gemeinsam,
-daß sie beide einen pointer auf char erwarten
unterschieden sich darin,
- daß foo zusätlich verspricht, mit x keinen Blödsinn anzustellen ( ihn unverändert zu lassen ) ??

Hanns

Shade Of Mine

Original erstellt von ^Hanns:
**>> temp ist ein pointer auf char, also müssten die ZEichen aus "name" an der adresse beginnen, auf die temp zeigt ( &temp ) !?
**

Das verstehe ich leider nicht - was meinst du damit?

> wenn ich das richtig überlegt habe, müsste ich jetzt
- char* buffer = new char ( mit der länge von "name" + 1) ( wegen chr(0))erzeigen
- den Inhalt von "name" in buffer kopieren ,
- ein 0x0 ins letzte Element setzen, und
- den Inhalt an jeder gewünschten Stelle ( buffer [x]) verändern,
- und buffer als parameter an tuNochwas übergeben ?

korrekt
korrekt
nein - das macht strcpy schon für dich
korrekt
korrekt

> d.h. eine funtion foo ( const char* x ) und fuu ( char* x) hätten gemeinsam,
-daß sie beide einen pointer auf char erwarten
unterschieden sich darin,
- daß foo zusätlich verspricht, mit x keinen Blödsinn anzustellen ( ihn unverändert zu lassen ) ??

korrekt

Hanns[/QB][/QUOTE]

Bashar

Interessanter ist das schon wieder ein verkappter C++-Beitrag. Was soll das? Das C++-Forum existiert!

*Hanns

Original erstellt von Shade Of Mine:
**[quote]Original erstellt von ^Hanns:
[qb]>> temp ist ein pointer auf char, also müssten die ZEichen aus "name" an der adresse beginnen, auf die temp zeigt ( &temp ) !?
**

Das verstehe ich leider nicht - was meinst du damit?

> - "name" ist als const char* definiert:
-- es ist nicht veränderbar ( const),
-- "name" ist ein pointer ( * ), zeigt also auf eine Speicherstelle
deren adresse durch &namezu erfahren sein müsste,
-- an dieser Adresse steht das erste Zeichen ( char) meines "textes"
-- es sind insgesamt Länge des Textes * Paltzbedarf eines char in Byte
byte reserviert + 0x0
-- dieser Bereich ist nciht veränderbar ??
--- keine Veränderbarketi bezogen audf die Länge, leuchtet mir ein
--- da ich das ganze als ein Array con char betrachten kann,
( dessen "0"-tes Element an &name liegt, müsst es legal und möglich sein, einzelne Elemente zu verändern ? (z.b. in einer Schelife 0-9 dateien "x0" bis "x9" zu behandeln ?

Wenn das soweit richtig ist, habe ich es wohl verstanden, und ich hoffe, es hat auch anderen genutzt.
Das nächste wäre dann wohl, wie man das Provlem mit Zeigern angeht.
Wenn Du das auch noch mit mir durchgehen magst, sehr gern.
Auf alle Fälle erst einmal eine schöne Woche, und Dank für Deine Hilfe soweit
Hanns

> wenn ich das richtig überlegt habe, müsste ich jetzt
- char* buffer = new char ( mit der länge von "name" + 1) ( wegen chr(0))erzeigen
- den Inhalt von "name" in buffer kopieren ,
- ein 0x0 ins letzte Element setzen, und
- den Inhalt an jeder gewünschten Stelle ( buffer [x]) verändern,
- und buffer als parameter an tuNochwas übergeben ?

korrekt
korrekt
nein - das macht strcpy schon für dich
korrekt
korrekt

> d.h. eine funtion foo ( const char* x ) und fuu ( char* x) hätten gemeinsam,
-daß sie beide einen pointer auf char erwarten
unterschieden sich darin,
- daß foo zusätlich verspricht, mit x keinen Blödsinn anzustellen ( ihn unverändert zu lassen ) ??

korrekt

Hanns[/QB][/QUOTE][/QB][/QUOTE]

*Hanns

Original erstellt von Bashar:
Interessanter ist das schon wieder ein verkappter C++-Beitrag. Was soll das? Das C++-Forum existiert!

Das verstehe ich nun nicht: ich hab die Probleme doch in C und in c++
Wieso ist es dann hier falsch ??

Hanns

p.s.
ich hab eben bemerkt, daß meine letzte Antwort nicht auf einen Beitrag von Dir kam.

Auch anDich meinen Dank für die Hilfe

Hanns

Bashar

Dein Programm ist kein C-Programm. Wenn du C++ programmierst und ein Problem hast, solltest du im C++-Forum fragen.

SG1

Original erstellt von Bashar:
Dein Programm ist kein C-Programm. Wenn du C++ programmierst und ein Problem hast, solltest du im C++-Forum fragen.

Wie kommst Du auf die Idee, dass es ein C++-Problem ist? Ich kann nichts C++-spezifisches entdecken.

Daniel E.

new.

^Hanns: _Bitte_ versuche doch jenau zu kennzeichnen, was dein Text ist und was Du zitierst (Dann besser gar nicht zitieren). So blick ich da nicht mehr durch.

*Hanns

Ok,
ich war den ganzen Tag aushäusig,
da bin ich nun wieder, und will versuchen, Klarheit zu bringen:

In der Tat sind die Probleme innerhalb eines C++ Programmes aufgetaucht, doch wennich mich recht entsinne, hatte die C-Fibel die Const char*. Aus diesem Grunde habe ich es hier gepostet. c++ spezifische Dinge habe ich doch nicht angesprochen ??
Am 13.10 hat Bashar mich unter Punkt 2 gefragt:
*2. Angenommen, dein strcpy-Aufruf würde strcpy(temp, name) lauten. Wohin würde strcpy die Zeichen aus «name» kopieren? (Tipp: Alloziere Speicher)

Meine Antwort drauf war*

> temp ist ein pointer auf char, also müssten die Zeichen aus "name" an der adresse beginnen, auf die temp zeigt ( &temp ) !?

Shade OfMine verstand dies nicht. Ich will versuchen, es suáuberer auszudrücken:
( korrigioert mich bitte, falls falsch)
-Ein Pointer zeigt immer auf die auf eine Speicher-Adresse and der sich das erste "Element" befindet.: alle weiteren "Teile" stehen sizeof(typus) weiter*

- den Speicherpaltz erhalte ich durch "&" vor dem Var-Namen
- für const char* c = "abc" könnte die adresse lauten ...4711.
- dann sähe die Belegung so aus:

adr....471 + 0 * sizeof(char) = a
  adr....471 + 1 * sizeof(char) = b
  adr....471 + 2 * sizeof(char) = c
  adr....471 + 3 * sizeof(char) = 0x0

- strlen( c) liefert 3 ( ohne 0x0 )

möchte ich "c" nun als Ausgang für eine neue, zu verändernde var namens "d"
nehmen, wäre so vozugehen.
- ich erzeuge mir ein char array. zum Bsp. char buffer = char [],
und mache es um eins größer, als strlen berichtet ( 0x0 muß Platz haben)
- in diesen buffer kopiere ich meinen coant char c mit strcpy.
- dieses Arra sieht dann so aus:

b [0] =>  a
  b [1] =>  b
  b [2] =>  c
  b [3] =>  0x0

- möchte ich den Ihanlt von b auf "abd" andern, so weise ich zu :

b[2] = 'd';

- mit buffer rufe ich die Funktion auf, die als Param einen const char* erwartet

Puh, ich hoffe das war richtig, und ich habs gefressen.

Bliebe nur noch die Frage, wer hindert mich daran, den Inhalt von "c" zu verändern, indem ich sage

c [0] = 'A';

- Mault da der compiler ?
- oder lässt er mich dann in meine eigene Falle laufen ?
Falle in sofern, als ich mir ja am Anfang des ProgCodes wege "const" versprochen hatte, dies Ding sei konsatant ?

Hab ich das richtig verstanden ?

EInen schönen Abend noch , um 19.00 muß ich zur Orchesterprobe.
Hanns

PS.
ich habs noch nicht eingesetzt, wollt es erstmal verstehen.

&quot;Ändern&quot; eines const char* ??

"Ändern" eines const char* ??