strcat, umgekehrte Reihenfolge

[Herman Uh. (Gast)]

Hallo,

ich möchte gerne einige Zahlen in bestimmte Zahlenformate (bin, dec, 
hex) umwandeln und über uart rüberschicken.

Wie kann ich am besten dass so machen, dass ich "0b" voranstelle.
Das "Problem" ist, dass wenn ich mache,

strncat(prefix, buffer_int_conv, MAX-strlen(buffer_int_conv)+1);

wird der string prefix unnötig lang. Geplant ist alles in 
buffer_int_conv auszulagern. Dieses habe ich entsprechend groß angelegt, 
dann +prefix binäre Zahlen vom Typ int16_t reinpassen.

#define MAX  20
char buffer_int_conv[MAX];

void put_bin(int16_t value)
{
  const char prefix[] = "0b";
  itoa(value, buffer_int_conv, 2);
  strncat(buffer_int_conv, prefix, MAX-strlen(buffer_int_conv)+1);
  puts(buffer_int_conv);
}

[Unbekannt U. (Gast)]

void put_bin(int16_t value)
{
  char buffer[20];
  strcpy(buffer, "0b");
  itoa(value, buffer + strlen(buffer), 2);
  puts(buffer);
}

Oder:

void put_bin(int16_t value)
{
  char buffer[18];
  itoa(value, buffer, 2);
  putchar('0');
  putchar('b');
  puts(buffer);
}

[Rufus Τ. F. (rufus)]

Oder:

void put_bin(int16_t value)
{
  char buffer[18];
  itoa(value, buffer, 2);
  puts("0b");
  puts(buffer);
}

[Frank M. (ukw) (Moderator)]

Rufus Τ. Firefly schrieb:
> Oder:
>

> void put_bin(int16_t value)
> {
>   char buffer[18];
>   itoa(value, buffer, 2);
>   puts("0b");
>   puts(buffer);
> }
>

2x puts hintereinander geht nicht, da puts den String mit einem 
zusätzlichen '\n' ausgibt. Dann hättest Du nach dem "0b" zusätzlich ein 
'\n'.

Wie wärs damit:

void put_bin(int16_t value)
{
  char buffer[18];
  putchar('0');
  putchar('b');
  puts(itoa(value, buffer, 2));
}

[Eric B. (beric)]

> 2x puts hintereinander geht nicht, da puts den String mit einem
> zusätzlichen '\n' ausgibt.

void put_bin(int16_t value)
{
  char buffer[18];
  itoa(value, buffer, 2);
  fputs("0b", stdout);
  puts(buffer);
}

 ;-)

[Helmut L. (helmi1)]

Oder ganz einfach ein printf / sprintf verwenden.

[Rufus Τ. F. (rufus)]

Frank M. schrieb:
> 2x puts hintereinander geht nicht, da puts den String mit einem
> zusätzlichen '\n' ausgibt.

Ach, Mist, das hatte ich übersehen.

Alternative (so die Laufzeitumgebung das hergibt)

fputs.

Das nämlich macht's nicht.

[Frank M. (ukw) (Moderator)]

Helmut Lenzen schrieb:
> Oder ganz einfach ein printf / sprintf verwenden.

Tja, wenn das verflixte printf auch die Ausgabe einer Zahl im 
Bionärformat erlauben würde. Tut es aber nicht. ;-)

Okay, das ginge:

void put_bin(int16_t value)
{
  char buffer[18];
  printf("0b%s\n", itoa(value, buffer, 2));
}

Ist bisher die kürzeste Version. Aber bestimmt nicht die eleganteste. Da 
kommt es auf die Zielplattform an. Wird printf() unterstützt? Gibt es 
ein stdout für fputs()? Fragen über Fragen...

[Frank M. (ukw) (Moderator)]

Und hier die schnellste, die ohne itoa(), printf() und fputs() - und vor 
allem ohne Buffer auskommt:

void put_bin(uint16_t value)
{
    uint16_t i = 0x8000;

    putchar('0');
    putchar('b');

    while (i)
    {
        if (value & i)
        {
            putchar ('1');
        }
        else
        {
            putchar ('0');
        }
        value &= ~i;
        i >>= 1;
    }
    putchar ('\n');
}

Ich habe den Parameter übrigens von int16_t auf uint16_t geändert. 
Negative Binärzahlen finde ich nicht wirklich sinnvoll.

Nachteil der obigen Funktion: Es werden alle führenden Nullen gedruckt. 
Die könnte man noch mit einem Flag unterdrücken.... wenn man es denn 
will.

[Frank M. (ukw) (Moderator)]

Und weil es soviel Spaß macht, hier noch die obligatorische rekursive 
Methode:

static void put_bin2(uint16_t value)
{
    if (! value)
    {
        return;
    }
    put_bin2 (value >> 1);
    putchar ('0' + (value & 1));
}

void put_bin(uint16_t value)
{
    putchar ('0');
    putchar ('b');

    if (! value)
    {
        putchar ('0');
    }
    else
    {
        put_bin2(value);
    }
    putchar ('\n');
}

Diese kommt auch ohne Buffer aus, benutzt lediglich putchar() und 
unterdrückt sogar führende Nullen. Leider muss das ganze wegen des 
abschließenden '\n' in 2 Funktionen realisiert werden. Ohne 
Zeilenabschluss hätte eine Funktion als Konvertierungsfunktion gereicht. 
Das führende '0b' hätte man noch in die Abbruchbedingung der Rekursion 
mit reinnehmen können.

[Peter D. (peda)]

Frank M. schrieb:
> Und weil es soviel Spaß macht, hier noch die obligatorische rekursive
> Methode:

Auf dem AVR gulpt das ebenmal satte 64 Byte Stack.

[Frank M. (ukw) (Moderator)]

Peter Dannegger schrieb:
> Auf dem AVR gulpt das ebenmal satte 64 Byte Stack.

Ja, irgendwo muss der nicht mehr notwendige Buffer ja versteckt werden 
;-)

Das Ding würde ich auch niemals einsetzen. Das war ein rein 
theoretischer Ansatz mit der Rekursion als pures Spielzeug.

[Norbert (Gast)]

Na gut, von mir auch noch eine...

void put_bin(uint16_t value) {
    uint16_t i = 0x8000;

    putchar('0');
    putchar('b');
    do {
        putchar( value & i ? '1' : '0' );
    } while(i >>= 1);
}

[Unbekannt U. (Gast)]

Also, wenn schon rekursiv, dann aber richtig:

extern void putchar(uint8_t);

static void put_bit(uint16_t value, uint8_t bitnum)
{
  if (!bitnum) {
    putchar('\n');
    return;
  }

  putchar( value & 0x8000 ? '1' : '0' );

  return put_bit(value << 1, bitnum - 1);
}

static void skip_bit(uint16_t value, uint8_t bitnum)
{
  if (!bitnum) {
    putchar('0');
    putchar('\n');
    return;
  }

  if (value & 0x8000)
    return put_bit(value, bitnum);
  else
    return skip_bit(value << 1, bitnum - 1);
}

void put_bin(uint16_t value)
{
  putchar('0');
  putchar('b');
  return skip_bit(value, 16);
}

Mit ''avr-gcc -O2'' Version 4.82, Stack-Usage 4 Bytes, siehe Anhang...