# char wert anderem char zuweisen (char* )



## Dragon_Arch (23. Mai 2008)

Ich wusste nicht genau wie Ich mein Problem im Titel ausdrücken sollte 

Mein Problem :  Ich habe die Variable   file  (<- char)   und habe dieser Variablen eine zeichen länge von 64 zeichen gegeben .  Der nutzer gibt dan über ein cin  ein Wort ein, dieses Wort ist dan file .      Nun Übergebe Ich file an afile ( char variable )   . 

Hier das ganze in Code: 


```
const unsigned int länge64 = 65;
 char file[länge64], afile; //, bfile, cfile, dfile, efile;

 cin>>file;

char* file = &afile;

cout<<afile<<endl;
```

Das cout am Ende gibt nur |[   aus ,  woran liegt das ?   Was hab ich Falsch gemacht ? ( Ich kenn mich mit C++ immer noch nicht so gut aus ^^ )

Bin offen für Korrektur und andere Lösungs wege !


----------



## Teambeta (23. Mai 2008)

Dragon_Arch hat gesagt.:


> Ich wusste nicht genau wie Ich mein Problem im Titel ausdrücken sollte
> 
> Mein Problem :  Ich habe die Variable   file  (<- char)   und habe dieser Variablen eine zeichen länge von 64 zeichen gegeben .  Der nutzer gibt dan über ein cin  ein Wort ein, dieses Wort ist dan file .      Nun Übergebe Ich file an afile ( char variable )   .
> 
> ...



Mit der Zeile *char* file = &afile;* würdest du 
1. Die Variable file neudefinieren - von einem Array zu einem Zeiger - und
2. würdest du nicht afile einen Wert zuweisen, sondern der Variable file.

Was noch zu bemängeln ist, wäre, dass du afile als char und nicht als char-Zeiger deklariert hast.


----------



## Dragon_Arch (23. Mai 2008)

Ok , ist ja schon mal ne Antwort               Bin auf diesen weg gekommen da mich alle Foren und so bei diesem Thema verwirren  und noch ein Freund von mir , mir das so gezeigt hatte ^^ ... naja  .

 Wenn jemand lust hat hier was funktionierendes reinzuschreiben darf er das gerne tun  , ansonsten mach ich das irgendwan .


----------



## Teambeta (24. Mai 2008)

```
const unsigned int länge64 = 65;
char file[länge64], *afile; 

cin>>file;

afile = (char*)file;

cout<<afile<<endl;
```


----------



## Dragon_Arch (24. Mai 2008)

Danke  

Ich war ja schon nahe dran .    [Wenn ich weiterer cahr Probleme habe schreibe ich sie wieder hier rein , denke ich ^^]


----------



## Teambeta (24. Mai 2008)

Dein Problem ist aber nur ein kleines gewesen, haben am Anfang so viele.

char ist der eigentliche Datentyp der nur einen Byte halten kann.
Ein char Zeiger zeigt im Speicher auf eine Stelle wo ein char haust ( oder mehrere chars, beendend mit einem NULL ).
Ein char Array ist konstant, immer. Du kannst nur soviele Bytes in diesem Array halten,
bis du die maximale Größe dieses Array's erschöpft hast.



```
char cEinChar; // Ein Byte
char *cEinCharPointer, cNochEinChar; // Der Zeiger, aber Achtung: cNochEinChar ist KEIN Zeiger, wie du am Sternchen erkennst heftet dieser nur an der Variable "cEinCharPointer".
char cEinCharArray[256]; // ein char Array, mit dem Konstanten Wert 256. Du kannst hier also 256 Bytes ablegen.
```


----------



## Dragon_Arch (25. Mai 2008)

Ich hab das soweit alles am laufen und natührlich funktioniert es einwandfrei ,  nur wenn ich z.B.   afile (<- ist dafür z.B. E:\\TEST\\test.exe ) als     system("afile");     ausführen möchte geht dies nicht .       
   Wie kann man das nun zum Laufen bringen ?


----------



## devDevil (25. Mai 2008)

Na die Aussagen von Teambeta müssen wir mal korrigieren. Ein char ist als erstes der Datentyp für ein Zeichen. Wenn man sich einen Satz anguckt, ist dies eine Ansammlung von vielen Zeichen, von d.h. ein Array. Doch wie macht man kenntlich, wann das Ende eines Strings erreicht ist? Unter C wird es dadurch realisiert, das man zum char-Array noch ein Zeichen hinzufügt, das Nullterminierungszeichen '\0', was dem Wert 0 entspricht. Z.B. wird die Funktion strlen einfach durch eine Schleife realisiert, die solange hochzählt, bis array[x] == 0 ist. Dies kennzeichnet einen C-String.

Doch nicht jeder char-Array muss ein String sein. Es kann auch bsw. sein das man einen Wertebereich von -10 - +10 braucht. Warum dann einen Integer oder Short nutzen? Ein char ist nämlich dadurch, das jedes Zeichen einer Zahl entspricht ein normaler Integraler Datentyp, dessen Zahlenwerte auch als Zeichen ausgewertet werden können (vgl. ASCII-Tabelle).

NULL nutzt man dafür, um einen Zeiger auf Nichts zeigen zu lassen, bzw. auf die Adresse 0x0000000.


----------



## Teambeta (25. Mai 2008)

devDevil hat gesagt.:


> Na die Aussagen von Teambeta müssen wir mal korrigieren. Ein char ist als erstes der Datentyp für ein Zeichen. Wenn man sich einen Satz anguckt, ist dies eine Ansammlung von vielen Zeichen, von d.h. ein Array. Doch wie macht man kenntlich, wann das Ende eines Strings erreicht ist? Unter C wird es dadurch realisiert, das man zum char-Array noch ein Zeichen hinzufügt, das Nullterminierungszeichen '\0', was dem Wert 0 entspricht. Z.B. wird die Funktion strlen einfach durch eine Schleife realisiert, die solange hochzählt, bis array[x] == 0 ist. Dies kennzeichnet einen C-String.
> 
> Doch nicht jeder char-Array muss ein String sein. Es kann auch bsw. sein das man einen Wertebereich von -10 - +10 braucht. Warum dann einen Integer oder Short nutzen? Ein char ist nämlich dadurch, das jedes Zeichen einer Zahl entspricht ein normaler Integraler Datentyp, dessen Zahlenwerte auch als Zeichen ausgewertet werden können (vgl. ASCII-Tabelle).
> 
> NULL nutzt man dafür, um einen Zeiger auf Nichts zeigen zu lassen, bzw. auf die Adresse 0x0000000.



Richtig, NULL ist ebenfalls dieses Terminierungszeichen.


----------



## devDevil (25. Mai 2008)

Nein, NULL ist gerade zufällig so definiert (bei dir), muss es aber nicht. Es ist auch schonmal als

```
(void*)0
```
 definiert oder sonst was. 

Und dennoch stimmt deine Aussage nicht, das ein char-Array zwingend Nullterminiert sein muss!


----------



## Teambeta (26. Mai 2008)

devDevil hat gesagt.:


> Nein, NULL ist gerade zufällig so definiert (bei dir), muss es aber nicht. Es ist auch schonmal als
> 
> ```
> (void*)0
> ...



Zur 1. Aussage: Ja, stimmt. Ich hab wohl geschlafen.
Zur 2. Aussage: Müssen muss garnichts, wäre aber schlecht eine Zeichenkette auszugeben ( hier zusammengesetzt durch ein Array ) der kein Terminierungszeichen besitzt.


----------



## werrator (26. Mai 2008)

Hallo 
Ich habe ein ähnliches Problem, 
ich möchte eine Zeichenkette aus dem Main in eine Klasse übergeben, und dann diese klasse in einer Datei abspeichern, das aberspeichern funktioniert, nur die Zeichenkette bereitet mir sorgen, ich habe es mit char * versucht doch beim laden und ausgeben gibt er mir "lustige"Zeichen ich vermute mal eine Adresse...
ich benutze borland c++ builder 6
mein übergabe code ist:
Tur ist meine Klasse,

das steht im main:
cin>>Zeichenkette;
t=new Tur (it, Zeichenkette);

und das die deklaration in der Tur.h/.cpp:
Tur (int iturid, char * name)

habe quasie alle Zeichenketten als char * definiert und auch so übergeben

mfg


----------



## devDevil (26. Mai 2008)

Zeig mal die definition von deiner Variable "Zeichenkette" ...

Und gewöhn dir direkt mal const an.


----------



## werrator (26. Mai 2008)

char * Zeichenkette;

was ist der Vorteil von const ?

mfg


----------



## devDevil (26. Mai 2008)

Du fordest keinen Speicher an und greifst danach auf nen undefinierten Speicherbereich  Von d.h. is es normal das da nix anständiges drin steht.

Nimm std::string, dann kannst du beliebige Längen einlesen.

```
std::string input;
std::cin >> input;
```
 und was ich mit const meine? Wenn du einen Parameter innerhalb der Funktion nicht veränderst, kennzeichnet man ihn als const.

```
void foo(const char* string)
{ std::cout << string << std::endl; }
```
  Z.b. gibst dir std::string::c_str einen const char* zurück, damit du nichts direkt am String verändern kannst und somit die Verwaltung des Strings durcheinander bringen könntest!


----------

