C++ C++ Werte verschiedener Variablen in eine zusammenfügen

T_55

Lieutenant
Registriert
Feb. 2013
Beiträge
638
Hallo,

vorweg: Umsetzung in C++ (C auch ok)

Ich möchte die Werte aus verschiedenen Variablen in eine neue Zusammenfügen und zwar nach folgendem Schema.
Die Zielvariable hat zehn Stellen. In diesen Stellen gibt es Plätze die die Werte anderer Variablen aufnehmen sollen ungefähr so:

wert_A belegt Platz 1
wert_B belegt Platz 2,3
wert_C belegt Platz 4,5
wert_D belegt Platz 6,7,8,9,10

Also die Verteilung ist so: ABBCCDDDDD

Beispiel1:
int wert_A = 1; // 1Platz
int wert_B = 85; // 2Plätze
int wert_C = 77; // 2Plätze
int wert_D = 12345; // 5Plätze
Wenn diese Werte in die Zielvariable gelegt werden soll das Ergebniss so aussehen:
int Zielvariable = 1857712345;

Beispiel2: Jetzt wird es interessant
int wert_A = 0; // 1Platz
int wert_B = 85; // 2Plätze
int wert_C = 7; // 2Plätze
int wert_D = 345; // 5Plätze
Wenn diese Werte in die Zielvariable gelegt werden soll das Ergebniss so aussehen:
int Zielvariable = 850700345;
Hier fällt die erste Stelle weg weil A = 0. Werte die weniger Stellen haben als Plätze vorgesehen müssen trotzdem die nullen bekommen zB C = 7 wird zu 07 oder D = 345 wird zu 00345.

Beispiel3:
int wert_A = 0; // 1Platz
int wert_B = 0; // 2Plätze
int wert_C = 4; // 2Plätze
int wert_D = 7; // 5Plätze
Wenn diese Werte in die Zielvariable gelegt werden soll das Ergebniss so aussehen:
int Zielvariable = 400007;
Hier fallen die ersten 4 Stellen weg weil A = 0 und B = 00 und C mit 0 beginnt. Die vier Nullen vor Platz 10 entstehen weil D nur eine Stelle hat aber 5 Plätze belegt.

Ich hoffe es ist klar wie es gemeint ist. Die Schwierigkeit ist zum einen das zusammenführen ansich und vor allem die Zuweisung der Nullen wenn der Quellwert weniger Stellen hat als im Zielwert Plätze dafür vorgesehen sind. Jetzt suche ich dafür eine Lösung die möglichst effektiv und einfach ist, habe aber keine Ahnung wie man das machen kann.

Gruß
 
Zuletzt bearbeitet:
So schwer ist das nicht.

Du musst

a) mit Zehnerpotenzen multiplizieren
und
b) addieren

Ich halte mich hier kurz, weil sich das stark nach ner (Haus-) Aufgabe anhört.
 
Das ist eigentlich recht simpel. Du brauchst dafür nur Multiplikation und Addition. Beispiel als Pseudocode:
Code:
result = 0

result = result + A

result = result * (10 ^ Anzahl_Stellen_B)
result = result + B

result = result * (10 ^ Anzahl_Stellen_C)
result += C

usw.
 
Nein keine Hausaufgabe ich studiere weder Informatik noch bin ich Schüler. Es geht mir um das Erstellen von Identifizierungszahlen die verschiedene Informationen des Programms in sich tragen sollen.

Ich bin nicht so fit in Mathe wenn ich jetzt 00007 also 7*10 hoch 5 dann kommt bei mir 700000
Ergänzung ()

@ Limit: Danke ich probiere das gleich mal aus
 
Vergiss nicht, das Resultat als 64-Bit-Variable anzulegen, denn wenn A>1 ist kann es sonst zu einem Überlauf kommen.
 
Hi,

schmeis deine Zahlen in einen formatierten stringstream und dannach wandelst du das wieder in eine Zahl um.

mfg
 
Limit schrieb:
Das ist eigentlich recht simpel. Du brauchst dafür nur Multiplikation und Addition. Beispiel als Pseudocode:
Code:
result = 0

result = result + A

result = result * (10 ^ Anzahl_Stellen_B)
result = result + B

result = result * (10 ^ Anzahl_Stellen_C)
result += C

usw.
Super genial das funktioniert perfekt! Besser als Zauberei :-)


Giana schrieb:
Vergiss nicht, das Resultat als 64-Bit-Variable anzulegen, denn wenn A>1 ist kann es sonst zu einem Überlauf kommen.
stimmt, int hat bei 10 Stellen dann seine Grenze. Guter Hinweis ich nehme dann einfach unsigned int
Ergänzung ()

Ne quatsch bei 32bit brauche ich dann long long int !
Ergänzung ()

...


Noch eine Frage dazu, würde es auch umgekehrt funktionieren eine Variable aus dieser Zahl wieder rauszuziehen?
Wenn man jetzt aus 400007 den Wert C rausziehen möchte?

0000400007
ABBCCDDDD

-> C = 4

Gruß und besten Dank schon mal
 
Geht so ähnlich, brauchst nur ein Schritt mehr.
Durch 10^x teilen -> alles "hinterm Komma" fliegt weg
Ergebnis wieder mal 10^x und von der alten Zahl abziehen.
Wiederhohlen

Pseudocode
Code:
int code = 123456;
int A = code / 10^6; // A = 1
code = code - A * 10^6; //code = 23456
int B = code / 10^5; // B = 2
code = code - B * 10^5; code = 3456
 
Zuletzt bearbeitet:
Wenn du den Wert nur lesen willst ohne ihn zu zerstören, kannst du mit dem modulo-Operator arbeiten um immer einen Teil des Wertes "auszuschneiden":

Code:
function cut(X, start, length)
  return X % 10^start / 10^(start - length)

X = 1857712345
A = cut(X, 10, 1) // A = 1
B = cut(X, 9, 2) // B = 85
C = cut(X, 7, 2) // C = 77
D = cut(X, 5, 5) // D = 12345
 
Wenn du das ganze statt im Zehnersystem in der Binärdarstellung machst gibt es dafür sogar support von C++:
Code:
typedef struct {
    unsigned char A :  4; // [0..16)
    unsigned char B :  7; // [0..128)
    unsigned char C :  7; // [0..128)
    unsigned int D  : 17; // [0..131072)
} code_t;

code_t c;
c.A = 1;
c.B = 85;
c.C = 77;
c.D = 12345;
Über eine union kannst du den entstehenden Typ auch als uint64_t verwenden.
 
Zuletzt bearbeitet: (fix)
Ergänzung vom 28.02.2016 18:41 Uhr: Ne quatsch bei 32bit brauche ich dann long long int !
Tip am Rande: Nach Möglichkeit nicht die Typen int und long verwenden, sondern sowas wie uint64_t etc. aus <cstdint>. Gerade bei dem einfachen long variiert die tatsächliche Größe von System zu System.
 
Nach einiger Zeit nochmal eine Folgefrage. Mir ist aufgefallen, dass die Funktion pow von <cmath> im Debug fehlerhaft arbeitet. Im Release ist alles prima aber beim Debug kommen minimal andere Werte raus. Wieso ist das so? Compiler ist MinGW32

Grüße
 
Es werden nur Integer verarbeitet. ZB als Ergebnis kommt statt einer 9 (Release) eine 8 (Debug) also genau eine Ganzzahl Differenz
 
Und da haben wir schon das Problem: pow gibt immer ne floating point Zahl zurück. In deinem Fall wird wahrscheinlich aus 8.999999347855... bei der Zuweisung zur integer variable 8, während der compiler das ganze im Release modus wegoptimiert (bzw. anders optimiert).
 
Danke für die Erklärung mit dem floating point das klingt schwer danach. Besteht denn die Gefahr das auch mal beim Release die Zuweisung "falsch" passiert? Ist es möglich ein wirklich sicheres Integer zu bekommen?
Ergänzung ()

Erledigt

Alles klar ich habs per round(pow(x)) besiegt :D
 
Zuletzt bearbeitet:
Wofür brauchst du überhaupt pow? Potenzen von Integern mit kleinen Exponenten kann man besser durch wiederholte Multiplikation berechnen, dann stimmt wenigstens das Ergebnis.
 
Zurück
Oben