Stellen eines unsigned int's extrahieren...

Jo ich danke erstmal allen Helfenden...!!!!

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

Swordfish

Ähm...
warum nicht sowas:

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

groovemaster

Glaube ich nicht. Oder glaubst du, dass Stringstreams zaubern?

Danke, aber mir geht es nicht um die Stellenanzahl, sondern um die Ziffer an einer bestimmten Position .

CStoll

Um an eine bestimmte Stelle zu gelangen, hast du doch schon eine Methode (und die lässt sich auch für die Nachkommastellen anwenden:

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))

Hi und danke^^

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

ten

<< Digit schrieb:

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...

ne0r

<< 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).

David_pb

ne0r schrieb:

<< 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

ne0r

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.

ne0r

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

David_pb

ne0r schrieb:

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!

ten

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)

David_pb

ten schrieb:

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

ne0r

Nachrichtentext:

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. Entschuldige bitte a) das Missverständnis b) Meine Art und Weise Aber: Ich habe meinen Code ausprobiert, und er funktioniert. Ich habe auch gesagt, dass es mir um Stellen im 256-System, nicht im Dezimalsystem ging. Abgesehen davon habe ich gesagt, das 12345 nur eine Beispielszahl ist. Für diese ist das 3te und 4te Byte Null. Nur ging es mir eben nicht um das konkrete Beispiel, sondern um das Verfahren im Allgemeinen. Und wenn man einzelne Oktette aus dem Int extrahieren möchte, funktioniert das ganze einwandfrei. Versuch bitte mich zu verstehen, ich bin mir ziemlich sicher, dass das ein blödes Missverständnis ist.
(Btw.: Ich habe mich bei meinen Angaben an dem Buch "C++ , die professionelle Referrnz" orientiert, das von einem Mitglied des ANSI/ISO Komittees geschrieben wurde, deswegen war ich mir so sicher, was mein Vorgehen angeht. Wenn man nämlich die nützliche Tabelle aus dem Buch benutzt, in der die Mindestgrößen von allen elementaren Datentypen angegeben ist, kann man eigentlich ganz feine Sachen auf bit-Ebene anstellen ) Nochmals Sorry

ne0r schrieb:

Nachrichtentext:
1. Entschuldige bitte a) das Missverständnis b) Meine Art und Weise Aber: Ich habe meinen Code ausprobiert, und er funktioniert. Ich habe auch gesagt, dass es mir um Stellen im 256-System, nicht im Dezimalsystem ging. Abgesehen davon habe ich gesagt, das 12345 nur eine Beispielszahl ist. Für diese ist das 3te und 4te Byte Null. Nur ging es mir eben nicht um das konkrete Beispiel, sondern um das Verfahren im Allgemeinen. Und wenn man einzelne Oktette aus dem Int extrahieren möchte, funktioniert das ganze einwandfrei. Versuch bitte mich zu verstehen, ich bin mir ziemlich sicher, dass das ein blödes Missverständnis ist.
(Btw.: Ich habe mich bei meinen Angaben an dem Buch "C++ , die professionelle Referrnz" orientiert, das von einem Mitglied des ANSI/ISO Komittees geschrieben wurde, deswegen war ich mir so sicher, was mein Vorgehen angeht. Wenn man nämlich die nützliche Tabelle aus dem Buch benutzt, in der die Mindestgrößen von allen elementaren Datentypen angegeben ist, kann man eigentlich ganz feine Sachen auf bit-Ebene anstellen ) Nochmals Sorry

Das Dein Code funktioniet streitet ja keiner ab, aber er hat ABSOLUT NIX MIT DEM THEMA HIER ZU TUEN

Wie verbohrt muß man eigendlich sein um konstant am Thema vorbeizudiskutieren nur um allen zu beweisen, daß man ja Recht hat.

So, daß mußte mal raus...

ne0r

Entschuldigung... (Soll nicht wieder vorkommen, habs gelernt ^^" )

hustbaer

Swordfish schrieb:

Ähm...
warum nicht sowas:
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

Das ist garantiert NICHT schneller als eine "herumrechnerei", sondern u.U. sogar um Grössenordnungen langsamer.

groovemaster

David_pb schrieb:

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

Nunja, ich würde nicht unbedingt externe Quellen heranziehen, wenn es um die Spezifikationen von C++ geht. Denn dass ein Byte mindestens 8 Bit haben muss, ist nicht korrekt. Wenn ich mich richtig erinnere, ist das in C so. Aber nicht in C++. Der Standard definiert ein Byte ungefähr wie folgt:
- gross genug, um mindestens jedes Zeichen des "basic execution character set" zu fassen
- genaue Anzahl an Bits ist implementationsspezifisch
- das "basic execution character set" entspricht dem "basic source character set" plus 3 Steuerzeichen und dem Nullzeichen
- das "basic source character set" besteht aus 96 Zeichen
Wenn man daraus eine Mindestgrösse für ein Byte "interpretieren" möchte, dann wäre das 7.

HumeSikkins

groovemaster schrieb:

David_pb schrieb:

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

Nunja, ich würde nicht unbedingt externe Quellen heranziehen, wenn es um die Spezifikationen von C++ geht.

Das ist im Allgemeinen ein guter Tipp. In diesem konkreten Fall ist die externe Quelle allerdings korret.

Denn dass ein Byte mindestens 8 Bit haben muss, ist nicht korrekt. Wenn ich mich richtig erinnere, ist das in C so. Aber nicht in C++.

Da irrst du dich. Auch in C++ besteht ein Byte aus mindestens 8 Bit. Der C++ Standard inkludiert den C-Standard quasi "per Referenz". Für diesen Fall ist, wenn ich das richtig sehe, u.A. 3.9 relevant (insbesondere Fußnote 37).