Hilfe nötig für vereinfachung einer c Funktion

[Martin Teuer (Gast)]

Hallo,
ich habe eine FUnktion geschirben in c aber ich denke sie ist sehr 
kompliziert? Kann man diese einfacher schreieben??

#include <stdio.h>
#include <string.h>

int main()
{
        char str[] = "69:66:84:1A:0E:E7:E5:51:30:82:60:A7:27:F2:A5:54:56:B9:15:19";
        int init_size = strlen(str);
        char delim[] = ":";
        char test[200];
        char test1[200];
        char *ptr = strtok(str, delim);
        int firstrun = 1;
        while(ptr != NULL)
        {
                if (firstrun == 1) {
                        sprintf(test, "0x%s", ptr);
                        firstrun = 0;
                }
                else {
                        sprintf(test, ", 0x%s", ptr);
                }
                strcat(test1, test);
                ptr = strtok(NULL, delim);
        }
        printf("%s", test1);
        return 0;
}

[A. S. (Gast)]

Die Funktion ist sinnlos. Sie gibt einen festen Output aus

Wenn Du sagst, was sie machen soll, kann man darüber diskutieren wie.

[Sebastian (Gast)]

Gib am Anfang "0x" aus, und dann lauf durch str und gib jedes Zeichen 
ausser : aus, und bei : gib ", 0x" aus.

LG, Sebastian

[Helmut -. (dc3yc)]

Du hast nirgends eine Funktion geschrieben. Alles steht im 
Hauptprogramm.

[Martin L. (tempusertempuser)]

Es soll aus
69:66:84:1A:0E:E7:E5:51:30:82:60:A7:27:F2:A5:54:56:B9:15:19
Folgendes geformt werden
0x69, 0x66 .....0x19


Ich weiss es ist in der Main Funktion um zu testen.

Danke für die Hilde

[A. S. (Gast)]

Martin L. schrieb:
> Es soll aus
> 69:66:84:1A:0E:E7:E5:51:30:82:60:A7:27:F2:A5:54:56:B9:15:19
> Folgendes geformt werden

Naja, das tut es. Nicht als Funktion, nicht variable, nicht auf 
irgendwas optimiert, ...

Du kannst z.b. anfangen, doppelten Code zu eliminieren.

Oder ohne strcat, nur sprintf. Das ist aber ohne Ziel oder Wortlaut der 
Aufgabe Kaffeesatzleserei

[Martin L. (tempusertempuser)]

Ich wäre dankbar wenn jdm erfahrenes einfach Tipps geben kann oder eine 
Optimierung meiner Lösung durchführt?

Programm soll Macher auf einem esp laufen

[wozu (Gast)]

welchen Sinn macht es denn ":" durch "," zu ersetzen?

Und wenn man weiß, dass es Zahlen sind, dann sieht man auch sofort dass 
es hex-Zahlen sind. Wozu dann noch "Ox" davor?

Oder willst du Zahlen aus dem String extrahieren?

[Martin L. (tempusertempuser)]

wozu schrieb:
> welchen Sinn macht es denn ":" durch "," zu ersetzen?
>
> Und wenn man weiß, dass es Zahlen sind, dann sieht man auch sofort dass
> es hex-Zahlen sind. Wozu dann noch "Ox" davor?
>
> Oder willst du Zahlen aus dem String extrahieren?


Es ist ein String die stellen müssen extrahiert werden und dann mit 0x 
davor. Am Ende soll wieder ein String rauskommen

[wozu (Gast)]

strtok-Funktion verändert deinen Originalstring.

[Martin L. (tempusertempuser)]

Was muss ich dann machen?

[Joachim B. (jar)]

Martin L. schrieb:
> Am Ende soll wieder ein String rauskommen

wieso wenn es doch 8-Bit Hexwerte sind?
Dann könnte statt ein String auch gleich ein uint8_t Array rauskommen.

Der original "String" belegt Speicher, hinterher brauchst du für 0x 
definitiv pro Byte 2 Byte mehr, also müsstes dafür Speicher 
bereitstellen.
Ich würde ja 2-stufig vorgehen.
1. Byte zählen : +1
2. malloc für Anzahl 4x der gezählten Byte wegen
0
x
Byte
,

etwa auch noch space?

Martin L. schrieb:
> Folgendes geformt werden
> 0x69, 0x66 .....0x19

dann ja
2a. malloc für Anzahl 5x der gezählten Byte wegen

0
x
Byte
,
<SPACE>

[Martin L. (tempusertempuser)]

Ja uint8_t Array wäre auch super....sorry bin nicht so gut im 
programmieren.....

Könntest du die Funktion in c code schreiben?

[wozu (Gast)]

Martin L. schrieb:
> Ja uint8_t Array wäre auch super

Mensch, darum habe ich auch gefragt welchen Sinn es macht ":" durch "," 
im String zu verändern.

[Sebastian W. (wangnick)]

Martin L. schrieb:
> Ich wäre dankbar wenn jdm erfahrenes einfach Tipps geben kann oder eine
> Optimierung meiner Lösung durchführt?

Immer noch? Tipp und Optimierung hab ich doch schon gegeben! Aber gut, 
etwa so:

#include <stdio.h>
#include <string.h>

void convert (char* from, char* to) {
    memcpy(to,"0x",2); to += 2;
    for (; *from; from++) {
        if (*from==':') {
            memcpy(to,", 0x",4); to += 4;
        } else {
            *to++ = *from;
        }
    }
    *to = 0;
}

int main() {
    char str[] = "69:66:84:1A:0E:E7:E5:51:30:82:60:A7:27:F2:A5:54:56:B9:15:19";
    char out[200];
    convert(str,out);
    printf("%s\n",out);
    return 0;
}

LG, Sebastian

[Joachim B. (jar)]

Martin L. schrieb:
> Könntest du die Funktion in c code schreiben?

ja

[wozu (Gast)]

Zahlen extrahieren:

   char str_in[] = "69:66:84:1A:0E:E7:E5:51:30:82:60:"
                   "A7:27:F2:A5:54:56:B9:15:19";

   char* end = str_in;

   while (1) {
      char* start = end;
      long hex = strtol (start, &end, 16);

      printf ("hex: %lx\n", hex);

      if (!*end) {
         break;
      }

      end++;
   }

Dann kannst du die Zahlen in einem Array speichern (statt sie 
auszugeben).

[Joachim B. (jar)]

Sebastian W. schrieb:
> char str[] =
> "69:66:84:1A:0E:E7:E5:51:30:82:60:A7:27:F2:A5:54:56:B9:15:19";
>     char out[200];

gilt doch nur für bekannte Stringlängen und wenn der String mal länger 
wird crashed es

wozu schrieb:
> Dann kannst du die Zahlen in einem Array speichern (statt sie
> auszugeben).

auch dazu müsste man zählen und Speicher reservieren, oder man nimmt den 
Speicher von Input und legt ja gleich dort ohne : und ohne 0x wieder ab, 
dann wäre das kein String sondern nur ein Bytearray.

[wozu (Gast)]

Aus dem String "FF" wird kein byte-Wert von 255.

[Sebastian W. (wangnick)]

Joachim B. schrieb:
> gilt doch nur für bekannte Stringlängen und wenn der String mal länger
> wird crashed es

Das ist aber kein Problem der Funktion convert() sondern des Aufrufers 
... :)

Ok, dann also:

    char out[strlen(str)*4+3];

https://onlinegdb.com/ziUUevzGY

Dann crashed auch char str[] = "::::" nicht!

LG, Sebastian

[A. S. (Gast)]

Martin L. schrieb:
> Ich wäre dankbar wenn jdm erfahrenes einfach Tipps geben kann oder eine
> Optimierung meiner Lösung durchführt?
>
> Programm soll Macher auf einem esp laufen

Deine Frage macht keinen Sinn. Du solltest schreiben, wofür Du das haben 
möchtest. Ist es eine Hausaufgabe, willst Du ein (ganz anderes) Problem 
lösen?

Dein Code funktioniert vermutlich, ist aber sehr fragil. Die Aufgabe ist 
aber nur eine Fingerübung, ähnlich der Folge "asdf jklö" im 
Schreibmaschinenkurs. Da macht es auch keinen Sinn, das "irgendwie 
eleganter" zu schreiben.

[DPA (Gast)]

Hier mal noch als posix shell script:

f(){
  ( IFS=:; printf ", 0x%s" $* | tail -c +3; )
}
f 12:fa:5e

Oder mit sed:

echo 12:ab:cd | sed "s/^/0x/;s/:/, 0x/g"

[PittyJ (Gast)]

Ich verstehe das Problem nicht. Die Funktion besteht aus einer Schleife 
mit einer If-Abfrage. Das ist schon fast das wenigste, was Funktionen so 
im Normalfall machen. Was ist daran jetzt komliziert?

Funktionen mit 100 Zeilen sind die Regel, und auch schon mal 500 Zeilen 
habe ich gesehen.

[Martin Teuer (Gast)]

ich habe es versucht nun mit

uint8_t finalout[20];
  for (int i = 0; i <strlen(out); i++) {
sscanf(out[i], "%x", finalout[i]);
}

in ein uint_8t array zu verandeln aber es klappt nicht.
Was ist daran falsch?

[A. S. (Gast)]

Martin Teuer schrieb:
> ich habe es versucht nun mit [...]
> in ein uint_8t array zu verandeln

Was denn? Hast Du einen lauffähigen(Compilerbären) Code? Soll das 
irgendwo in dein main reinpassen ? Was kommt rein, was soll rauskommen? 
Hast Du scanf verstanden und Mal in einfacher Form benutzt?

[Jobst Q. (joquis)]

Martin Teuer schrieb:
> ich habe eine FUnktion geschirben in c aber ich denke sie ist sehr
> kompliziert? Kann man diese einfacher schreieben??

Als Quelltext sieht es noch relativ einfach aus. Für das, was die CPU zu 
tun hat, ist es aber ziemlich kompliziert und aufwendig. Das liegt vor 
allem an den benutzten Funktionen sprintf, strtok und strcat, die sie 
unnötigerweise auszuführen hat.

Wenn man die Aufgabe direkt mit Pointern löst, hat sie schätzungsweise 
nur ein hundertstel davon zu tun. Etwa so:

char * convertTo0x(char *t,const char *s,char *lim){

int firstrun=1;

lim--;
while (*s && t<lim){
  if(*s==':' && (t+4)<lim){
    s++;
    *t++=',';
    *t++=' ';
    *t++='0';
    *t++='x';
    }
  else if (firstrun && (t+2)<lim){
    *t++='0';
    *t++='x';
    firstrun = 0;
    }
  else *t++=*s++;
  }
*t=0;
return t;
}

Der Aufruf mit deinen Variablen:
convertTo0x(test1,str,test1+sizeof(test1));

Diese Funktion ist zudem durch die Variable lim noch überlaufsicher. In 
deiner Version müsstest du statt sprintf snprintf verwenden und dabei 
die Puffergröße immer wieder neu berechnen.

[stringende (Gast)]

Jobst Q. schrieb:
> return t;

Das wäre dann die Adresse vom Stringende

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Helmut -. schrieb:
> Du hast nirgends eine Funktion geschrieben. Alles steht im
> Hauptprogramm.

main() ist eine Funktion wie jede andere auch. Der einzige Unterschied 
zu anderen Funktionen besteht darin, dass in den meisten(!) 
Laufzeitumgebungen main() die zuerst aufgerufene Funktion des 
Anwenderprogramms ist. Nicht mehr und nicht weniger.

[Einer (Gast)]

void convert(char * dest, char * src)
{
  while (*src) {
    *dest++ = '0'; *dest++ = 'x';
    while (*src && *src != ':')
      *dest++ = *src++;
    if (*src) {
      *dest++ = ','; *dest++ = ' ';
      src++
    }
  }
  *dest = 0;
}

Wer will kann ja noch beliebige Fehlerabfragen dazubauen.

Ist halt eine Frage davon, was die Spezifikation ist. Wenn garantiert 
ist, dass der Eingangs-String korrekt ist und der Ziel-Buffer groß 
genug, kann man sich das sparen. Wenn nicht, muss halt noch etwas 
Kleinkram dazu.

[Jobst Q. (joquis)]

stringende schrieb:
> Jobst Q. schrieb:
>> return t;
>
> Das wäre dann die Adresse vom Stringende

Genau. In diesem Fall vielleicht nicht notwendig, aber sehr praktisch, 
wenn man noch etwas anhängen möchte. Der Stringanfang ist ja eh bekannt.

[Einer (Gast)]

Eigentlich kann man es noch brutaler schreiben, wenn es auf jede 
Mikrosekunden ankommt:

void convert(char *dest, char *src) 
{
    goto start;
    do {
        *dest++ = ','; *dest++ = ' ';
        src++;
    start:
        *dest++ = '0'; *dest++ = 'x';
        *dest++ = *src++; *dest++ = *src++;
    } while (*src);
    *dest = 0;
}

[Einer (Gast)]

Und wenn man noch eine Zeile Code sparen will...

void convert(char *dest, char *src) 
{
    goto start;
    do {
        *dest++ = ','; *dest++ = ' ';
    start:
        *dest++ = '0'; *dest++ = 'x';
        *dest++ = *src++; *dest++ = *src++;
    } while (*src++);
    *dest = 0;
}

...lustig, oder?

[A. S. (Gast)]

Einer schrieb:
> ...lustig, oder?

naja, das letzte ++ im Schleifenkörper muss dann weg.

[A. S. (Gast)]

Einer schrieb:
> ...lustig, oder?

oder nur

void convert(char *d, char *s)
{
    do {
        *d++ = '0'; *d++ = 'x';
        *d++ = *s++; *d++ = *s++; 
    } while (*d = *s++ && *d++ = ',' && *d++ = ' ');
}

[Martin L. (tempusertempuser)]

Und wie konvertiert man das in ein uint8_t Array?

[boah (Gast)]

warum muss man DAS (einen weiteren String) jetzt plötzlich nach int 
konvertieren?

warum dieser Umweg?

[A. S. (Gast)]

Martin L. schrieb:
> Und wie konvertiert man das in ein uint8_t Array?

naja, solange Du nichts zur eigentlichen Aufgabe sagst:

void convert(uint8_t *a, char *s)
{
    while(*s) {
        *a=     *s>='A'?*s  -'A':*s  -'0';
        *a*= 16;
        *a+++=*++s>='A'?*s++-'A':*s++-'0';
    } 
}

Ich bezweifle nur, dass Du mit den Antworten etwas anfangen kannst. Was 
spricht dagegen, die Aufgabe zu beschreiben?

[boah (Gast)]

wozu schrieb:
> Zahlen extrahieren:
>    char str_in[] = "69:66:84:1A:0E:E7:E5:51:30:82:60:"
>                    "A7:27:F2:A5:54:56:B9:15:19";
>    char* end = str_in;
>    while (1) {
>       char* start = end;
>       long hex = strtol (start, &end, 16);
>       printf ("hex: %lx\n", hex);
>       if (!*end) {
>          break;
>       }
>       end++;
>    }

da steht es doch schon.

statt printf muss er die Werte halt in einem Array ablegen:

arr[i++]=hex;

[Andreas H. (ahz)]

Martin Teuer schrieb:
> Hallo,
> ich habe eine FUnktion geschirben in c aber ich denke sie ist sehr
> kompliziert? Kann man diese einfacher schreieben??

Ja.

#include <stdio.h>
int main()
{
    puts("0x69, 0x66, 0x84, 0x1A, 0x0E, 0xE7, 0xE5, 0x51, 0x30, 0x82, 0x60, 0xA7, 0x27, 0xF2, 0xA5, 0x54, 0x56, 0xB9, 0x15, 0x19");
    return(0);
}

Erfüllt Deine Anforderung^^

/regards

[Dirk B. (dirkb2)]

Martin L. schrieb:
> Und wie konvertiert man das in ein uint8_t Array?

Warum muss der ESP denn diese Hexziffern convertieren?

Muss das unbedingt im laufenden Betrieb sein oder reicht das zur compile 
time aus?

[Joachim B. (jar)]

Martin Teuer schrieb:
> ich habe es versucht nun mit
> uint8_t finalout[20];
>   for (int i = 0

warum wählst du int für i?
kann denn dein i je negativ werden?
Beim Programmieren sollte man doch die Wahl der Variablen überdenken und 
passend wählen.

[🐧 DPA 🐧 (Gast)]

Machen wir das doch mal richtig. Mit einem richtigen Lexer:

%{
#include <stdio.h>
%}
%option noyywrap

hexnum [0-9a-fA-F][0-9a-fA-F]?
delimiter [:]

%%

{hexnum}    { printf("0x"); ECHO; }
{delimiter} { printf(", "); }

%%

int main(int argc, char* argv[]) {
  yylex() ;
  return 0;
}

lex -o hex.c hex.l

hex.c ist dann der C code.

gcc -o hex hex.c
echo 12:34:a7 | ./hex

[Rolf M. (rmagnus)]

Joachim B. schrieb:
> Martin Teuer schrieb:
>> ich habe es versucht nun mit
>> uint8_t finalout[20];
>>   for (int i = 0
>
> warum wählst du int für i?

Besser wäre size_t, da sizeof auch diesen Typ zurückgibt.

> kann denn dein i je negativ werden?

Gegenfrage: Muss es einen Bereich von mehr als 2 Milliarden abdecken 
können?

[A. S. (Gast)]

Rolf M. schrieb:
>Gegenfrage: Muss es einen Bereich von mehr als 2 Milliarden abdecken können?

Zumal ab 20 der ganze Code eh broken ist. Als wäre int/uint ein Problem, 
dass der TO schon hätte.

[🐧 DPA 🐧 (Gast)]

#include <stdio.h>
#include <stdint.h>
#include <assert.h>

static inline int hex2num(unsigned char ch){
  if(ch >= '0' && ch <= '9')
    return ch - '0';
  if(ch >= 'A' && ch <= 'Z')
    return ch - 'A' + 10;
  if(ch >= 'a' && ch <= 'z')
    return ch - 'a' + 10;
  return -1;
}

int parsehex(size_t n, const char hexstr[n], uint8_t result[(n+3)/3]){
  if((n+1)%3)
    return -1;
  int res = 0;
  const char* in  = hexstr;
  uint8_t* out = result;
  while(1){
    int num;
    if((res=hex2num(in[0])) == -1)
      return -1;
    num  = res * 0x10;
    if((res=hex2num(in[1])) == -1)
      return -1;
    num += res;
    *out = num;
    if(!in[2]) break;
    if(in[2] != ':')
      return -1;
    in  += 3;
    out += 1;
  }
  return 0;
}

int main(){
  const char input[] = "69:66:84:1A:0E:E7:E5:51:30:82:60:A7:27:F2:A5:54:56:B9:15:19";
  uint8_t output[sizeof(input)/3];
  assert(parsehex(sizeof(input)-1, input, output) != -1);
  for(size_t i=0; i<sizeof(output); i++){
    if(i) printf(", ");
    printf("0x%.2X", output[i]);
  }
  puts("");
}