Deklaration char in switch-Anweisung

[Andre (Gast)]

Hallo,

ich hoffe man kann erkennen was ich mit meinem Problem ansprechen 
möchte. Wieso ist es nicht möglich t[] unterschiedliche Text in einer 
Switch-Anweisung zu geben. t wird weiter unten an eine andere Funktion 
übergeben die den Text an ein LCD-Display sendet. Habe nun schon einiges 
ausprobiert, bekomme aber immer wieder Error angezeigt. Was mache ich 
falsch...(bin noch recht jungfräulich was die C-Programmierung betrifft)


switch (einstellungsbit)
{
case 1:
  einstellungsbit = 10;
  char t[] = "Texte";
  break;

case 10:
  einstellungsbit = 100;
  char t[] = "Texte LCD 1";
  break;

case 20:
  einstellungsbit = 200;
  char t[] = "Texte LCD 2";
  break;
}







oder ist es irgendwie so möglich:

char t[100] = "Texte LCD 1";
char t[110] = "Texte LCD 2";
char t[200] = "Klingel 1 oben";
char t[210] = "Klingel 2 unten";



ich bin am verzweifeln.....und für jede Antwort Dankbar

[Karl H. (kbuchegg)]

  char t[40];   // Platz für 40 Zeichen

  switch (einstellungsbit)
  {
  case 1:
    einstellungsbit = 10;
    strcpy( t, "Texte" );
    break;
 
  case 10:
    einstellungsbit = 100;
    strcpy( t, "Texte LCD 1" );
    break;
 
  case 20:
    einstellungsbit = 200;
    strcpy( t, "Texte LCD 2" );
    break;
 }

das ist eine Möglichkeit.
Die benutzt du dann, wenn die Taxte nach der switch-case
noch verändert werden müssen (daher auch das Umkopieren
der Texte in ein char-Array, in dem sie später noch
Bearbeitet werden können).

Braucht man keine derartige Flexibilität, sprich die Texte
werden danach nicht verändert, dann geht auch sowas:

  const char* t;

  switch (einstellungsbit)
  {
  case 1:
    einstellungsbit = 10;
    t = "Texte";
    break;
 
  case 10:
    einstellungsbit = 100;
    t = "Texte LCD 1";
    break;
 
  case 20:
    einstellungsbit = 200;
    t = "Texte LCD 2";
    break;
 }

Noch einfacher ist es allerdings, wenn deine case Werte
nach einem bestimmen Muster folgen, also formelmässig
errechenbar sind. Wenn du zb nur die case Werte 10, 20 und 30
hast:

char* Texte[] = { "Texte",
                   "Texte LCD 1",
                   "Texte LCD 2"
                }
                   

  const char* t;
  t = Texte[einstellungsbit / 10];

Auch hier wieder: Wenn die Texte im nachhinein noch bearbeitet
werden sollen, dann muss man sie zunächst mal umkopieren:

char* Texte[] = { "Texte",
                   "Texte LCD 1",
                   "Texte LCD 2"
                }
                   

  char t[40];
  strcpy( t, Texte[einstellungsbit / 10] );
  strcat( ":" );

[Oliver (Gast)]

Mit char t[] = "xxxx" deklarierst du die Variable mehrfach, und das 
darfst du nunmal nur einmal tun.

Stringzuweiseungen gehen nach der deklaration nur noch per strcpy (oder 
memcopy);

Also

char t[MAX_LAENGE]; // hier sollte das Feld mit der maximalen 
Textlänge+1 !! (für die 0) angelegt werden.

switch (einstellungsbit)
{
case 1:
  einstellungsbit = 10;
  strcpy (t,"Texte");
  break;

usw.

}

Oliver

[Oliver (Gast)]

Karl heinz tippt einfach schneller...

[Karl H. (kbuchegg)]

Oh. Hab ich vergessen.
Zu deiner ursprünglichen Frage:

Du kannst deshalb nicht in jedem case eine neue Variable
t deklarieren, weil du dann im gleichen Block viele Variablen
mit demselben Namen t hast. Der Block beginnt bei der
öffnenden { und endet bei der schliessenden }.

D.h. so

switch (einstellungsbit)
{                                      <----- hier beginnt der Block
case 1:
  einstellungsbit = 10;
  char t[] = "Texte";
  break;

case 10:
  einstellungsbit = 100;
  char t[] = "Texte LCD 1";
  break;

case 20:
  einstellungsbit = 200;
  char t[] = "Texte LCD 2";
  break;
}                                      <---- und hier endet er wieder

ein 'case' erzeugt keinen neuen Block. Das heist aber auch
das was du vorhast ist im Grunde gleichbedeutend mit

   {
      int i = 5;
      int i = 8;
      int i = 12;
   }

und das das nicht gehen kann, liegt ja auf der Hand.

Du kannst aber sehr wohl in jedem case einen eigenen Block
eröffnen:

switch (einstellungsbit)
{
case 1:
  {
    einstellungsbit = 10;
    char t[] = "Texte";
  }
  break;

case 10:
  {
    einstellungsbit = 100;
    char t[] = "Texte LCD 1";
  }
  break;

case 20:
  {
    einstellungsbit = 200;
    char t[] = "Texte LCD 2";
  }
  break;
}

Dann hat jedes case seinen eigenen Block und die Variable
t gibt es nur während der entsprechende case ausgeführt wird.
Im obigen macht das natürlich keinen Sinn, denn

case 10:
  {
    einstellungsbit = 100;
    char t[] = "Texte LCD 1";       <---- hier wird t erzeugt
  }                                 <---- und hier stirbt es auch
                                          schon wieder
  break;

aber ein

case 10:
  {
    einstellungsbit = 100;
    char t[40] = "Texte LCD 1";
    strcat( t, " : " );
    strcat( t, name );
    lcd_puts( t );
  }
  break;

würde durchaus Sinn machen.

[Andre (Gast)]

DANKE für die schnelle und ausführliche Beantwortung meiner 
Frage...werde mein kleines Programm gleich mal umschreiben.

Eine Frage habe ich aber noch:

Was bedeutet das  bei char und diese Sternchen finde ich z.B. auch bei 
der ein oder anderen Funktion in meinem Programm. (Wahrscheinlich hat 
das * völlig unterschiedliche Funktionen)

Beispiel:

void eauswarten2(int ms, volatile uint8_t *p,uint8_t b)   * vor dem p?


und wieso wird diese Funktion so aufgerufen:

eauswarten2(5, &PORTB, PB6);          warum muss da jetzt dieses & 
davor?



Schon jetzt herzlichen Dank für dir Beantwortung
Gruß André

[Karl H. (kbuchegg)]

Andre wrote:
> DANKE für die schnelle und ausführliche Beantwortung meiner
> Frage...werde mein kleines Programm gleich mal umschreiben.
>
> Eine Frage habe ich aber noch:
>
> Was bedeutet das  bei char und diese Sternchen finde ich z.B. auch bei
> der ein oder anderen Funktion in meinem Programm. (Wahrscheinlich hat
> das * völlig unterschiedliche Funktionen)

Möglich.
An dieser Stelle ist es aber ein 'Pointer' Stern. Diese Variable
ist also eine Pointer-Variable, also eine Variable die eine
Speicheradresse beinhaltet.

  char c;
Diese Variable hält einen Character

  char* i;
diese Variable enthält eine Speicheradresse. Wenn man im
Speicher an genau dieser Adresse nachsieht, dann erhält
man einen char.

Nun kann man im Speicher aber nicht fuhrwerken wie man lustig
ist. Insbesondere muss ein Pointer immer auf reservierten
Speicher zeigen (Im Speicher liegen ja schliesslich auch noch
andere Variablen)

   i = &c;

Das & gibt die Speicheradresse von c und diese Speicheradresse
wird in i gespeichert. Jetzt zeigt i also auf c.

  char a;
  a = *i;

i enthält eine Speicheradresse. Der * dereferenziert den Pointer,
d.h. er holt aus dem Speicher einen Wert. Welchen Wert? Den
Wert der im Speicher an der Adresse abgelegt ist, die in i steht.

  *i = 'd';
Im Speicher, an der Adresse die in i steht, wird der Character 'd'
abgelegt.


Du solltest dir ein C Buch kaufen. Das sind absolute Grundlagen
und in jedem C Buch über viele Seiten hinweg beschrieben.