Kennst ihr eine Möglichkeit an die einzelnen Stellen eines Integers heranzukommen ?
Dies muss aber möglichst effizient geschehen, da /10 (als Beispiel) doch zu lange dauert, da ich diese 'Trennung' seht oft (Schleife) durchführen muss.

Mal einn kleineses beispiel:

int i = 345477;
short pos3; // hier soll nun die Zahl 5 drin stehen ;) .

Danke schonmal!

unsigned int i = 345477;
char *cp = reinterpret_cast<char*> (&i);

short s = cp[2];  //bzw. char s, je nach Notwendigkeit

nach der Zuweisung von cp, zeigt cp auf das Low-Order byte von i, also auf das byte, das für die Einser-Stelle zuständig ist. cp[1] wäre dann das byte, das für die 256-Stelle zuständig ist.

WTF?

@ten: glaubst du nicht ein vernuenftiger Compiler macht das selbst?

@ten: glaubst du nicht ein vernuenftiger Compiler macht das selbst?

vielleicht bei cpu's die keine 'div' instruction haben, sonst eher nicht.
aber ein eingebautes div kann auch sehr langsam sein...

der char-pointer (bzw. byte-pointer, da ein char genau einem byte entspricht) zeigt in diesem Beispiel genau auf das dritte byte des unsigned ints. (ok, es sollte lieber ein unsigned char* sein) damit kann man bytes aus einzelnen Variablen extrahieren, sollte das nötig sein.

Ok, einfacher wäre, sofern man nicht alle bytes in einzelne chars umlagern will:

const unsigned char bytenum = 3;
unsigned char c;
int i = 12345;

c = static_cast<unsigned char> (i >> (bytenum-1)*8);

Bei einer Zuweisung von int nach (u-)char werden alle bis auf das Low-Order Byte abgeschnitten. Man verschiebe die bits von i also um bytenum-1 nach Rechts, um das bytenum-ste Byte zu extrahieren.

@jesse:

der char-pointer (bzw. byte-pointer, da ein char genau einem byte entspricht) zeigt in diesem Beispiel genau auf das dritte byte des unsigned ints. (ok, es sollte lieber ein unsigned char* sein) damit kann man bytes aus einzelnen Variablen extrahieren, sollte das nötig sein.

Ok, einfacher wäre, sofern man nicht alle bytes in einzelne chars umlagern will:

const unsigned char bytenum = 3;
unsigned char c;
int i = 12345;

c = static_cast<unsigned char> (i >> (bytenum-1)*8);

Bei einer Zuweisung von int nach (u-)char werden alle bis auf das Low-Order Byte abgeschnitten. Man verschiebe die bits von i also um bytenum-1 nach Rechts, um das bytenum-ste Byte zu extrahieren.

Glaubst du echt daran dass das funktioniert? Wenn dann musst du das tatsächlich erst in einen String umwandeln, z.B. so:

char c = lexical_cast< std::string, int >( i )[ 3 ];

grüße

Aber werde das warscheinlich doch mit einfacher (Modulo-)Division machen .

Aber noch eine kleine Frage:
Wie komme ich an die Stellen eines long double wertes heran ?

Also Beispiel:

long double wert = 457756.4562;
short teilnk3 = ...; // hier soll 6 drinstehen
// oder:
short teilvk4 = ...; // hier soll 7 drinstehen

template <typename T>
unsigned long get_num_digits( const T &value ) {

    std::stringstream ss;

    ss << static_cast< int >( value );
    return ss.str( ).length( );
}

??

Ich befürchte sogar, dass das schneller ist als jegliche herumrechnerei...

Greetz, Swordfish

int stelle = (int)(zahl/pow(10,pos)) % 10;

(für die Stellen nach dem Komma setzt du entsprechend negative Werte für 'pos' ein (pos=0 ergibt die Einer, pos=3 die Tausender, pos=-3 die Tausendstel-Stelle))

Gibts da auch ne Möglichkeitt ohne pow (würde das gerne auf elementarer Ebene lösen ).

Hi und danke^^
Gibts da auch ne Möglichkeitt ohne pow (würde das gerne auf elementarer Ebene lösen ).

ich hatte weiter oben ein kapitel aus einem buch gepostet. besorg dir dieses buch, da stehen solche sachen drin wie z.b. 'integer potenzieren ohne schleifen' und ähnliche bitschubsereien...

Hi und danke^^

Gibts da auch ne Möglichkeitt ohne pow (würde das gerne auf elementarer Ebene lösen ).

Auf elemtarer Ebene lässt sich das nunmal nur per "Bit-Schubserei" lösen. Also solltest du entweder ten's Ratschlag befolgen, oder selbst im Internet nach bestimmten Tutorials suchen, da findest du sicher was.

@David_pb:
Ich WEISS dass es funktioniert. Wenn du mir nicht glaubst, probier es aus. Ist an sich einfachstes bitweises Operieren:

i sei mal: 00000000 00000001 00000010 00001111 (die Wahl des Wertes ist willkürlich)

nun verschieben wir i um 8*1 nach rechts, um das 2te Byte zu bekommen:

i: 00000000 00000000 00000001 00000010

dann static_cast<unsigned char> (i) :
00000010
(static_cast, bzw. cast allgemein schneidet alle größeren Stellen so zu sagen ab.)

Ich sehe darin kein Problem. Auch benutze ich das bei meiner (auf dem 256-System basierenden) Klasse für große Zahlen, und die funktioniert bisher einwandfrei (jedenfalls das, was ich davon bereits implementiert habe).

<< Digit schrieb:

Hi und danke^^

Gibts da auch ne Möglichkeitt ohne pow (würde das gerne auf elementarer Ebene lösen ).

Auf elemtarer Ebene lässt sich das nunmal nur per "Bit-Schubserei" lösen. Also solltest du entweder ten's Ratschlag befolgen, oder selbst im Internet nach bestimmten Tutorials suchen, da findest du sicher was.

@David_pb:
Ich WEISS dass es funktioniert. Wenn du mir nicht glaubst, probier es aus. Ist an sich einfachstes bitweises Operieren:

i sei mal: 00000000 00000001 00000010 00001111 (die Wahl des Wertes ist willkürlich)

nun verschieben wir i um 8*1 nach rechts, um das 2te Byte zu bekommen:

i: 00000000 00000000 00000001 00000010

dann static_cast<unsigned char> (i) :
00000010
(static_cast, bzw. cast allgemein schneidet alle größeren Stellen so zu sagen ab.)

Ich sehe darin kein Problem. Auch benutze ich das bei meiner (auf dem 256-System basierenden) Klasse für große Zahlen, und die funktioniert bisher einwandfrei (jedenfalls das, was ich davon bereits implementiert habe).

Du scheinst den ganzen Aufbau von Integer und Bytekette nicht ganz zu verstehen.
Dein Code:

const unsigned char bytenum = 3;
unsigned char c;
int i = 12345;

c = static_cast<unsigned char> (i >> (bytenum-1)*8);

12345 im Binärsystem = 0011 0000 0011 1001b

Jetzt shiftest du 3-1 = 2 * 8 = 16 Bits nach rechts. Raus kommt:
0000 0000 0000 0000b das dann boch in ein Char konvertieren und du hast ein Char mit dem Wert 0. Wow, und sowas soll funktionieren!

Würde jetzt jede Komponente ein Byte (in diesem Fall 8 Bit) im int belegen würde deine Idee funktionieren, so wie's aber ist tut das ganze nicht...

grüße

Erstens besteht ein byte aus 8 bit. Damit ist deine Darstellung nicht ganz richtig, das was du dargestellt hast sind 4 Nibble (2 Byte) (Bin mir nicht ganz sicher, ob das Nibble heisst ).
Wenn du das ganze um 16 nach rechts shiftest, hast du natürlich 00000000 im char. Deine Darstellung benutzt ja auch einen short int (2 Byte), keinen normalen bzw, long int (= int). Ein int hat (bei mir) sizeof(int) = 4, also 4 byte (C++ ist byte-basiert). Bei Shift nach rechts um 16 bekommst du also das dritte byte.

Probier mal in einem unsigned int 256*256*256*255 zu speichern. Dann speicher mal 256*256*256*256. Vorher hast du so etwa 4 Milliarden, danach null. Warum? Es wird versucht ins fünfte byte zu schreiben (Ein byte hat die Wertemenge [0;255] ).

Bzw. Darstellung vorher:
11111111 00000000 00000000 00000000

Danach:

(00000001) 00000000 00000000 00000000 00000000
Das eingeklammerte byte existiert nicht. Ergo Wird der Wert des ints null.

Probier das jetzt bitte aus, bevor du mir wieder widersprichst.

Jetzt weiß ich, was du meintest, natürlich hast du Recht
12345 ist nur ein Beispielwert, genauso wie bytenum. Ich hab nicht darüber nachgedacht, ob das ganze null werden könnte

Probiers halt einfach aus.

Erstens besteht ein byte aus 8 bit. Damit ist deine Darstellung nicht ganz richtig, das was du dargestellt hast sind 4 Nibble (2 Byte) (Bin mir nicht ganz sicher, ob das Nibble heisst ).
Wenn du das ganze um 16 nach rechts shiftest, hast du natürlich 00000000 im char. Deine Darstellung benutzt ja auch einen short int (2 Byte), keinen normalen bzw, long int (= int). Ein int hat (bei mir) sizeof(int) = 4, also 4 byte (C++ ist byte-basiert). Bei Shift nach rechts um 16 bekommst du also das dritte byte.

Probier mal in einem unsigned int 256*256*256*255 zu speichern. Dann speicher mal 256*256*256*256. Vorher hast du so etwa 4 Milliarden, danach null. Warum? Es wird versucht ins fünfte byte zu schreiben (Ein byte hat die Wertemenge [0;255] ).

Bzw. Darstellung vorher:
11111111 00000000 00000000 00000000

Danach:

(00000001) 00000000 00000000 00000000 00000000
Das eingeklammerte byte existiert nicht. Ergo Wird der Wert des ints null.

Probier das jetzt bitte aus, bevor du mir wieder widersprichst.

Um dich mal von deiner "ich weiß alles" Tour runterzubringen. Ich kenn mich mit den Thema zur genüge aus. Ich programmiere nicht erst seit Gestern und den Unsinn mach ich jeden Tag auf der Arbeit zur Genüge.

1. ein Byte ist nicht auf acht Bit festgelegt. Der Begriff Byte unterliegt zwar Kriterien, u.A. das es mindestens 8 Bit breit sein muss, aber es kann durchaus größer als 8 Bit sein.

2. Meine "Darstellung" ist sowohl als int (mindesten 16 Bit) als auch short int genau gleich. Auch wenn das int 32 Bit breit ist ist die Darstellung im Binärsystem die selbe, nur sind halt links noch weitere Nullen.

3. Egal ob du ein int (hier mal 32 Bit) oder ein short (hier mal 16 Bit) mit dem Wert 12345 um 16 Bit nach rechts shiftest, es wird immer den Wert 0 geben, ganz einfach weil das letzte gesetzte Bit in den 16 Bit enthalten ist.

4. Deine Idee würde dann funktionieren wenn jede Stelle der Zahl ein Byte belegen würde, das tut sie aber nicht, denn dann müsste deine Variable ja, in diesem Beispiel, 5 Byte groß sein.

ne0r schrieb:

Ach ja:

Jetzt weiß ich, was du meintest, natürlich hast du Recht
12345 ist nur ein Beispielwert, genauso wie bytenum. Ich hab nicht darüber nachgedacht, ob das ganze null werden könnte

Schön das dus trotzdem einsiehst. Deine Idee war zwar recht nett, ist aber nicht umsetzbar!

grüße

P.S.: Ich frage mich ob du deinen Code selbst ausprobiert hast. Das solltest du das nächste mal nämlich tun bevor du das anderen vorschlägst!

1. ein Byte ist nicht auf acht Bit festgelegt. Der Begriff Byte unterliegt zwar Kriterien, u.A. das es mindestens 8 Bit breit sein muss, aber es kann durchaus größer als 8 Bit sein.

'bytes' können auch weniger als 8 bits haben.
dieses 8-bittige dingens schimpft sich 'octet'
--> http://en.wikipedia.org/wiki/Octet_(computing)

David_pb schrieb:

1. ein Byte ist nicht auf acht Bit festgelegt. Der Begriff Byte unterliegt zwar Kriterien, u.A. das es mindestens 8 Bit breit sein muss, aber es kann durchaus größer als 8 Bit sein.

'bytes' können auch weniger als 8 bits haben.
dieses 8-bittige dingens schimpft sich 'octet'
--> http://en.wikipedia.org/wiki/Octet_(computing)

Byte, so der Begriff für C++ auszulegen ist, ist auf eine Mindestgröße von 8 Bit definiert, also quasi ein Octet.

Siehe hierzu: http://www.parashift.com/c++-faq-lite/intrinsic-types.html#faq-26.6