Joachim ... schrieb
> Ich weiß... ist zum Teil ziemlich umständlich und mehr gebastelt als
> professionell geschrieben, dies sollte jetzt aber nicht Grundlage einer
> Diskussion werden...
Jein.
Eigentlich sollte es das schon. Denn es zeigt sich, dass erstaunlich
viele Fehler auf gebastelten, nicht aufgeräumten und unübersichtlichen
Code zurückzuführen sind. Eben weil der Programmierer die Übersicht
verloren hat.
Räumt man den Code auf, dann ist der Fehler plötzlich für alle klar und
deutlich zu sehen.
> pattern_hex = &pattern_1[0] ; // liegt hier der Fehler?
> pattern_ram = &pattern[0]; // liegt hier der Fehler?
Die Frage kann man so nicht beantworten. Rein formal gibt es an dieser
Zuweisung nichts auszusetzen. Es fragt sich allerdings was du dir davon
versprichst, wenn du hier eine extre Pointervariable einsetzt. Wozu
brauchst du sie? Was bringt dir diese Variable, was dir eine direkte
Verwendung des Arrays nicht bringt (es gibt Fälle, wo man so ein
Konstrukt benötigt. kann aber mit dem bischen Code nicht verifiziert
werden)
>
1 | > void decToHex (unsigned char value, char *res){
|
2 | > unsigned char value1;
|
3 | > char result[2];
|
4 | >
|
5 | > //1.char
|
6 | > value1 = value; // mem
|
7 | > value1 /=16;
|
8 | > if (value1 > 9) value1 = value1 -10 + 'A' ;
|
9 | > else value1 += '0';
|
10 | > result[0] = value1;
|
11 | > *res = result[0];
|
12 | > //
|
13 | > //2.char
|
14 | > value1 = value;
|
15 | > value1 %=16;
|
16 | > if (value1 > 9) value1 = value1 -10 + 'A' ;
|
17 | > else value1 += '0';
|
18 | > result[1] = value1;
|
19 | > *(res+1)= result[1];
|
20 | > *(res+2)= result[2] = 0;
|
21 | > }
|
22 | >
|
Der Code ist heftig kompliziert. Wenn du realisiert hast, dass diese
Funktion im Prinzip aus 2 Teilen besteht, die konzeptionell das Gleiche
machen, dann solltest du das auch in einer eigenen Funktion
manifestieren. Mal sehen, wo uns das hinführt
1 | char toHexNibble( unsigned char nibble )
|
2 | {
|
3 | if( nibble > 9 )
|
4 | return nibble - 10 + 'A';
|
5 |
|
6 | return nibble + '0';
|
7 | }
|
8 |
|
9 | void decToHex (unsigned char value, char *res)
|
10 | {
|
11 | res[0] = toHexNibble( value >> 8 ); // oberen 4 Bit, aka High-Nibble
|
12 | res[1] = toHexNibble( value & 0x0F ); // unteren 4 Bit, aka Low-Nibble
|
13 | res[2] = '\0';
|
14 | }
|
ich würde mal sagen: das Aufräumen hat sich gelohnt. Das ganze Gebilde
ist einfach und die Funktionsweise ist leicht nachzuvollziehen. Es ist
auch leicht zu verifizieren, dass die Funktion an sich korrekt ist, wenn
der Aufrufer für res die Adresse eines Arrays übergibt, welches gross
genug ist. Man kann auch aus dem Code ganz leicht ablesen, dass der
Aufrufer ein Array mit mindestens einer Länge von 3 angeben muss.
Ein Aufruf der Form
1 | unsigned char var =29; //Test
|
2 | char pattern_1[] = "00";
|
3 |
|
4 | ...
|
5 | decToHex( var, pattern_1 );
|
6 | ...
|
ist daher vollkommen in Ordnung.
Huch, da ist ja jetzt fast die Hälfte Code weggefallen! Und was übrig
bleibt, ist auch noch leichter zu verstehen und nachzuvollziehen das es
korrekt ist. Und genau das hab ich in der Einleitung gemeint, warum sich
solche Diskussionen lohnen.
> *(res+1)= result[1];
warum verwendest du hier Pointersyntax, wenn du nicht musst? Die
Pointersyntax bringt dir hier nichts, ausser das der Code kompliziert
aussieht.
Thread beobachten
Seitenaufteilung abschalten