AVR-GCC warnings

[Timo P. (latissimo)]

Hallo!

1) warning: array subscript has type 'char'

Bin ich beim AVR-GCC gezwungen, den subscript als int zu wählen? Mein 
SRAM platzt schon aus allen Nähten. Ich hab sogar nen Bitfeld für meine 
ganzen Flags genutzt.

2) warning: function returns address of local variable
Warum bekomme ich dazu eine Warning? MUSS/SOLL ich unbedingt eine 
globale oder eine übergebene Variable nutzen?(z.B. als char* übergeben?)
Code dazu:

const char * byte_to_binary(char byte)

{
  char binary[9]={'\0'};

  if(byte&0x01)
  strcat(binary,"1");
  else 
  strcat(binary,"0");
  return binary;
}

Danke für Antworten!

[Peter (Gast)]

du darst keine Zeiger von einer Stack variabel zurückgeben

[MicroSD (Gast)]

Timo P. schrieb:
> 2) warning: function returns address of local variable
> Warum bekomme ich dazu eine Warning?

Weil die Lokale Variable vor dem Return wieder aufgeräumt/freigegeben 
wird. dein Rückgabewert ist also ein Pointer auf eine nicht mehr belegte 
Stack-Position.
Dort stehen zwar normalerweise noch die richtigen Werte, müssen aber 
nicht. => Es ist zufall, ob dein Programm funktioniert.

Ausserdem: Deine "strcat"-Schleife ist suboptimal (Komplexität O(n^2)), 
das geht ohne strcat viel besser.

[Timo P. (latissimo)]

Dann werde ich der fkt. einfach ein weiteres arg. vom typ char* 
verpassen und ihr dann eine ext. var mit übergeben.



Komplexität O(n^2) als alternative zu strcat sagt mir nichts....

[Peter (Gast)]

Timo P. schrieb:
> Komplexität O(n^2) als alternative zu strcat sagt mir nichts....

dir fehlt noch irgendwie eine schleife, du willst ja 8bit anhängen. Was 
Timo sagen wollte ist das strcat jedesmal das ende des strings sucht und 
dann dort etwas anhängt. Das ist aber nicht sinnvoll.
du braucht dir nur die aktuell position zu merken und kannst dort direkt 
die 0 oder 1 reinschreiben und am ende eine \0. also komplett ohne 
strcat arbeiten.

[Timo P. (latissimo)]

dann mach ich es in einer Schleife, in der ich die stelle [i] anspreche. 
Dann mache ich es statisch für 8 bit vars. Den string, den ich bereit 
stellen sollte, kann ich dann immernoch mit 0x00 terminieren nach der 
Schleife.

Welchen Nachteil hat strcat denn? Ist es so rechen/Zeitintensiv?

Übrigens: Danke für eure Antworten!

[Jörg W. (dl8dtl) (Moderator)]

Timo P. schrieb:

> 1) warning: array subscript has type 'char'
>
> Bin ich beim AVR-GCC gezwungen, den subscript als int zu wählen? Mein
> SRAM platzt schon aus allen Nähten.

Was hat das eine mit dem anderen zu tun?

Array subscripts sind per C-Standard nun mal vom Typ "int".  Du
handelst dir insbesondere potenzielle sign extension Probleme ein,
wenn du einfach nur "char" nimmst.

Wenn schon, dann nimm uint8_t (aus <stdint.h>).

[Peter (Gast)]

Ich würde es so ähnlich machen...

const char * byte_to_binary(char byte)
{
  
  static char binary[9];
  for(char i=0;i<8;i++)
  {
   if (byte & 0x80)
   {
     binary[i]='1';
   }
   else
   {
     binary[i]='0';
   }
   byte = byte < 1;
  }
  binary[8]=0;
  return binary;
}

[Peter II (Gast)]

Peter schrieb:
> Ich würde es so ähnlich machen...const char * byte_to_binary(char byte)
ich weiss nicht wie gut der compiler ist, aber man kann das noch etwas 
optimieren:

const char * byte_to_binary(char byte)
{
   static char binary[9];
   char* p = binary;
   for(char i=0;i<8;i++){
    if (byte & 0x80) {
      *p='1';
    } else {
      *p='0';
    }
    byte = byte < 1;
    ++p;
   }
   *p=0;
   return binary;
 }

[!p (Gast)]

if (byte & 0x80) {
      *p='1';
    } else {
      *p='0';
    }
    byte = byte < 1; //FALSCH --> <<
    ++p;

Kürzer:

*(p++)=byte & 0x80 + '0';
byte<<1;

ungeprüft


Alternativ

const char * byte_to_binary(char byte)
{
   static char binary[9]="00000000";
   for(uint8_t i=0;i<8;i++,byte<<=1)
   {
      binary[i]=byte&0x80+'0';
   }
   return binary;
 }

ungeprüft

[Stefan E. (sternst)]

!p schrieb:
> Kürzer:

Kürzer, aber auch falsch (wie auch die Alternative). Oder ergibt 
womöglich '0'+128 ein Zeichen, das so ähnlich wie eine '1' aussieht?

[Peter (Gast)]

Und nochmals falsch:

static char binary[9]="00000000";

...würde nur einmal vor dem Programmstart auf "00000000" initialisiert 
und nicht für jeden Funktionsaufruf, weil eben static!

[!p (Gast)]

Beides richtig, sorry, war in Gedanken woanders. Kann gelöscht werden.

schäm

[Klaus W. (mfgkw)]

Timo P. schrieb:
> 1) warning: array subscript has type 'char'
>
> Bin ich beim AVR-GCC gezwungen, den subscript als int zu wählen? Mein
> SRAM platzt schon aus allen Nähten. Ich hab sogar nen Bitfeld für meine
> ganzen Flags genutzt.

wenn schon, dann unsigned char - dann wird dein Index nicht negativ.

[Jörg W. (dl8dtl) (Moderator)]

Klaus Wachtler schrieb:

> wenn schon, dann unsigned char - dann wird dein Index nicht negativ.

Oder uint8_t, wie ich oben schon vorgeschlagen habe.  Kommt letztlich
auf dasselbe raus, aber man erkennt dabei sofort die Intention, einen
kleinen Integer-Datentypen zu nutzen.  Besser wäre noch uint_fast8_t,
denn nicht auf allen Plattformen spart die zwanghafte Benutzung von
nur 8 bits auch tatsächlich Code und/oder Zeit, und auf eine exakte
Wortbreite kommt es ja hier gar nicht an.