Verständnisfrage zu char

[Gast (Gast)]

Hallo zusammen,  wie gesagt habe ich eine Verständnisfrage zu char´s.
Ich habe folgende Zeilen:

 char Eheit2 =65;// 'A';

Diese Variable rufe ich in einer Funktion

 void xy (char *string, char* Einheit)

folgendermaßen auf.

 xy (Messwert, &Eheit2);

Nur wird beim Sprung in die Funktion die Variable ungewollt erweitert.
In der Funktion ist Einheit später sowas wie "A1200".

Die Variable Messwert ist ein char array.

 char Messwert[5];

Wenn ich aber so deklariere

 char *Eheit2 ={"A"};

läuft alles richtig.
Kann mir einer auf die Sprünge helfen??

[Suchender (Gast)]

Zeig mal den Rest vom Code... sonst ist raten angesagt...

Ich versuch mich mal am Raten. Du verwnedest in den Funktionen irgendwo 
eine string Funktion? Sowas wie strcpy vielleicht?

char Eheit2 =65;// 'A';

Hier fehlt die abschließende 0, der einen String abschließt. Bei der 
Version:

char *Eheit2 ={"A"};

wird diese 0 automatisch hinzugefügt, da "" ein string kennzeichnet -> 0 
am Schluss.

[Sören H. (dersoe)]

wäre evtl. noch hilfreich zu wissen mit was für einem Compiler du 
arbeitest...

[Michael G. (linuxgeek)]

Gast wrote:
> Nur wird beim Sprung in die Funktion die Variable ungewollt erweitert.
> In der Funktion ist Einheit später sowas wie "A1200".

Das ist klar, weil der String-Delimitter (\0) fehlt. Im Ernstfall 
wuerdest Du so einen totalen Absturz provozieren oder jede Menge Muell 
auslesen.

[Detlev T. (detlevt)]

Was machst du den später damit? printf? char * wird auch als string 
benutzt, das ist eine Zeichenkette, die mit einer null abgeschlossen 
wird. Wenn du "A" schreibst, ist das so ein String, in Wirklichkeit zwei 
Bytes, einer mit 65, einer mit null. 'A' hingegen nur ein Zeichen - ohne 
die abschließende null.

Ich vermute, dass du so etwas wie printf damit aufrufst und dann wird 
alles im Speicher ausgegeben - nicht nur das eine Zeichen -bis 
zufälligerweise irgendwann eine null auftaucht. Der Compiler meckert 
hier nicht, da es sich um einen logischen und nicht syntaktischen Fehler 
handelt.

-Mist, zu langsam. ;)

[Gast (Gast)]

  

char Messwert[5]; 
short xxx = 4;
int DatenWert =piffpaff, valuetowrite;
char *Eheit2 = {"A"};

while (xxx >=0)
  {
    if (DatenWert == 0)
      {
      Messwert[xxx] = 48;     //Entspricht der Null im ASCII
      xxx-=1;
      }
    else
    {
    valuetowrite = (DatenWert % 10);
    Messwert[xxx] = valuetowrite + 48;
    DatenWert = (DatenWert - valuetowrite)/10;
    xxx -=1;
    }
  }

UC1617_write_string_messwert(Messwert, Eheit2);

So sieht das bis zur aufrufenden Funktion aus.
Ich wandle einen short in ein char um und übergebe ihn incl. Einheit an 
die Funktion.

Und die Funktion sieht folgendermaßen aus:

void UC1617_write_string_messwert(char *string, char *Einheit)
{
 short n,u,uEinheit;
 char *Buchstabe = string;
 char *Eheit = Einheit;
  
  while (*Buchstabe == 48)    //Bleibt in der Schleife, solange ein Messwert eine 0 an erster Stelle hat.
          Buchstabe++;
  
  u = strlen (Buchstabe);
  uEinheit = strlen (Eheit);
 
     for (n=1; n<=((16 - (u+uEinheit))/2);n++)            //Auffüllen mit " "
      {
      UC1617_write_char(' ',Features);      //bis Mitte
      x+=2;
      } 
     
     while(*Buchstabe != '\0')
      {
        
      write_char (*Buchstabe,Features);
      Buchstabe ++;
      }
     
     while(*Eheit != '\0')
      {
        
      write_char (*Eheit,Features);
      Eheit ++;
      }
     for (n = (x+(2*u)); n<32;n+=2)                   //Auffüllen mit " "
      write_char(' ',Features);      //bis Zeilenende
    
}

Das ganze schreibt einen Wert auf ein Display.

[Suchender (Gast)]

Ja also genau das was wir vermutet hatten. Im ersten Fall hat einfach 
die "String-Kennzeichnung" gefehlt.

http://www.exforsys.com/tutorials/c-language/handling-of-character-strings-in-c.html

[Gast (Gast)]

Aber soll man eine Zuweisung wie

 char *Eheit2 = {"A"};

nicht vermeiden??

[Suchender (Gast)]

char *Zeiger = "TEXT";

ist völlig ok. Wüsste nicht, was dagegen spricht.

[Gast (Gast)]

Habe in einem Buch folgendes gelesen.

Aber Achtung, nachstehendes Programm könnte böse Folgen haben:

#include <stdio.h>

int main()
{
   int *y;
   *y=10;
   printf("Der Wert von *y ist %d\n",*y);
   return 0;
}

Dem Zeiger y wurde hier zuvor keine gültige Adresse zugewiesen. Dies 
bedeutet, dem Zeiger y steht beim Start des Programms eine Adresse zur 
Verfügung, die durch ein zufälliges Bitmuster vom Linker erzeugt wurde. 
Das Programm kann theoretisch sogar korrekt ablaufen. Irgendwann kann 
(wird) es jedoch ein vollkommen falsches Ergebnis zurückliefern. Auch 
könnte es sein, dass auf einen Speicherbereich zugegriffen wird, der 
bereits Daten beinhaltet. Dies könnte zu erheblichen Problemen bei der 
Programmausführung bis hin zum Absturz führen.

Ist das nicht genau das was ich gemacht habe?

[Suchender (Gast)]

Ok das ist was anderes. hier hast du zunächst einen Zeiger der irgendwo 
im Speicher hinzeigt.

int *y;

Dort schreibst du dann 10 rein! Überschreibst also wenn du pech hast was 
anderes.

aber bei

char *Zeiger = "TEXT";

wird der Zeiger auf den String "TEXT" im Speicher gelegt. Dieser String 
wurde zuvor aber im Speicher abgelegt und hat für ihn zugeordneten 
Speicher erhalten.

[Sören H. (dersoe)]

Fein wäre es gewesen, dir vorher entsprechend Speicher zu allokieren... 
sonst kann das tatsächlich ins Auge gehen. Das allerdings ist unabhängig 
von der abschließenden Null....

[Gast (Gast)]

Danke. Mit euren Antworten ist mir wieder einmal geholfen.