#define oder neue Varible gegen unübersichtlichkeit?

lord-maricek

Moin,

in einem Programm habe ich Koordinaten in einem struct gespeichert, die ich umrechne, damit ich sie in char arrays speichern kann.

Um auf eine Koordinate zuzugreifen muss ich jedesmal das hier schreiben:
_this->ship_info.lon oder _this->ship_info.lat

Wenn ich jedesmal in der Berechnung das einsetzen würde, wäre es extrem unübersichtlich.

Hier meine Berechnungen:
`arr[*indexer] = floor(lon);

*indexer += 1;

arr[*indexer] = floor((lon-floor(lon))/0.01);

*indexer += 1;

arr[*indexer] = floor(((lon/0.01)-(floor((lon/0.01))))/0.01);

*indexer += 1;

arr[*indexer] = floor(((lon/0.0001)-(floor((lon/0.0001))))/0.01);

*indexer += 1;

arr[*indexer] = floor(lat/100.0);

*indexer += 1;

arr[*indexer] = floor(lat);

*indexer += 1;

arr[*indexer] = floor((lat-floor(lat))/0.01);

*indexer += 1;

arr[*indexer] = floor(((lat/0.01)-(floor((lat/0.01))))/0.01);

*indexer += 1;

arr[*indexer] = floor(((lat/0.0001)-(floor((lat/0.0001))))/0.01);

*indexer += 1;`

Um in der Berechnung lon und lat verwenden zu können, habe ich zwei Möglichkeiten. Entweder interne Varibalen zu den Koordiaten erstellen und anfangs die Werte einmal zuweisen.

Ich habs momentan so gemacht, mit #define, und #undef.

`#define lon _this->ship_info.lon

#define lat _this->ship_info.lat

arr[*indexer] = floor(lon);

*indexer += 1;

arr[*indexer] = floor((lon-floor(lon))/0.01);

*indexer += 1;

arr[*indexer] = floor(((lon/0.01)-(floor((lon/0.01))))/0.01);

*indexer += 1;

arr[*indexer] = floor(((lon/0.0001)-(floor((lon/0.0001))))/0.01);

*indexer += 1;

arr[*indexer] = floor(lat/100.0);

*indexer += 1;

arr[*indexer] = floor(lat);

*indexer += 1;

arr[*indexer] = floor((lat-floor(lat))/0.01);

*indexer += 1;

arr[*indexer] = floor(((lat/0.01)-(floor((lat/0.01))))/0.01);

*indexer += 1;

arr[*indexer] = floor(((lat/0.0001)-(floor((lat/0.0001))))/0.01);

*indexer += 1;

#undef lon

#undef lat`

Jetzt ist die Frage, was ist schneller, anfangs 2 Varibalen zuerstellen, und denen die Koordinatenwerte zuweisen, oder meine #define Lösung?

MfG
Philipp

SeppJ

Das sollte letztendlich auf den gleichen Code hinauslaufen. Temporäre Variablen werden in der Regel wegoptimiert. Das ist eine ziemlich grundlegende Optimierung, dazu gehört kein Supersuper-Compiler.

Und guck dir deine Rechnung mal genauer an, das kann man super zu einer Schleife mit zwei Zeilen zusammenfassen. Und das schlägt an Eleganz und Lesbarkeit beide Möglichkeiten um Längen.

lord-maricek

Ok, danke

MfG
Philipp

Wutz

lord-maricek schrieb:

in einem Programm habe ich Koordinaten in einem struct gespeichert, die ich umrechne, damit ich sie in char arrays speichern kann.

Warum speicherst du deine Strukturen nicht binärkompatibel ab sondern rechnest irgendwas aus und das dann (wahrscheinlich) beim Lesen wieder rückzurechnen?

lord-maricek

Wutz schrieb:

lord-maricek schrieb:

in einem Programm habe ich Koordinaten in einem struct gespeichert, die ich umrechne, damit ich sie in char arrays speichern kann.

Warum speicherst du deine Strukturen nicht binärkompatibel ab sondern rechnest irgendwas aus und das dann (wahrscheinlich) beim Lesen wieder rückzurechnen?

Ich programmiere gerade ein Programm für einen Mikroprozessor. Die unterstützen die sprintf Funktion nicht mehr komplett, z.b. %f geht da nicht mehr. Außerdem braucht die Funktion zu viel Speicher und Rechenleistung, deswegen verwende ich die garnicht mehr.
Ich bekomme die Koordinaten als double von meinem GPS, und um damit rechnen zu können (Kurs, Distanz usw.) speicher ich die erstmal als double. Wenn die Koordinaten dann zum PC gesendet werden sollen, kann ich wie gesagt sprintf nicht nehmen, und deswegen rechne ich die so um.

MfG
Philipp

Wutz

Das beantwortet ja meine Frage nicht.
Wenn du von irgendwoher irgendeine Bytereihenfolge erhälst, die du dann als double/... interpretierst, was spricht dann dagegen, diese Bytes 'unverändert' an den PC weiterzuschicken?
Dein PC ist durchaus in der Lage, diese von dir im Zwischenschritt vorgenommene Konvertierung/Interpretation selbst zu machen, sprich dein C Programm auf dem PC erhält die ursprüngliche Bytereihenfolge, also z.B.

unsigned char daten[GROESSE];

unverfälscht und macht dann selbst alles notwendige.

lord-maricek

Moin,

ok, danke für den Tipp, aber wie kann ich bei einem Double auf die einzelnen Bits zugreifen?

Wenn ich einen char habe und dem einen double zuweise, werden dann die ersten 8 Bits im char gespeichert?
Dann könnte ich danach den die Bits im Double um 8 verschieben?
[double] >> 8?

Und dann immer so weiter?

MfG
Philipp

Wutz

Plattformungleiche Systeme tauschen Daten normalerweise über Bytefolgen aus (1 Byte = 8 Bit).
Die Interpretation dieser Bytefolgen ist aber plattformabhängig und nur bedingt standardisiert, für Fließkommazahlen spezifiziert ANSI C erstmal nichts.
Dein GPS liefert also irgendeine Bytefolge und bildet darin seine Werte nach seinem Gutdünken ab, idealerweise nach einem möglichst weit verbreiteten Standard.
Dieses Verhalten musst du/dein Compiler kennen, um es interpretieren zu können, also z.B. wieviele Bytes belegt das GPS für eine reelle Zahl, wieviele Zahlen werden geliefert, wie erfolgt die Abbildung der reellen Zahl in den Bytes.
Der kleinste gemeinsame Nenner aus C Sicht ist für solche Bytefolgen

unsigned char *bytefolge;

Stimmt die Reell-Zahlen-Abbildung deines C Compilers mit der deines GPS überein, geht einfach:

double reellezahl;
reellezahl = *(double*)bytefolge;
bytefolge += sizeof(double); /* naechsten Wert aus Bytefolge interpretieren: */
reellezahl = *(double*)bytefolge;

Stimmt die Reellzahlen-Abbildung deines Compilers nicht mit der deines Datenlieferanten überein, sollte es entsprechende Bibliotheksfunktionen für deinen Compiler und dein Datenliefersystem geben, andernfalls musst du dir eben anhand der GPS Dokumentation was nach o.g. Beispiel selbst bauen.
unsigned char kennt jeder C Compiler und ist für o.g. Datenaustausche meistens möglich.

lord-maricek

Ok, danke, dann werde ich das so umsetzten.

MfG
Philipp