binäres int nach dezimal konvertieren



  • unsigned int foo(unsigned int bin)
    {
    	unsigned int num = 0;
    	for(int i = 0; bin != 0; ++i)
    	{
    		num += bin%10 << i;
    		bin /= 10;
    	}
    	return num;
    }
    


  • Er will binär nach dezimal:

    int bin2dec(const std::string &bin) 
    { 
        int num = 0; 
    	int rdx = 1;
        //durch den string rückwärts iterieren 
        for(std::string::const_reverse_iterator i=bin.rbegin();i!=bin.rend();++i) 
        { 
            int digit = *i-'0'; //zeichen in eine zahl konvertieren 
            num += digit*rdx; 
    		rdx *= 2;
        }
        return num; 
    }
    


  • Hallo,

    @sebi707:

    den algo kenn ich schon und der funktioniert auch prima, ABER sobald die zahl mit 0 beginnt, funktioniert es nicht mehr.

    @roflo:

    hier übergebe ich wieder einen string.
    ich habe immernoch das problem, dass ich eine int zahl, die mit 0 beginnt,
    nicht vernünftig zu string bekomme.



  • Da hast du wohl einen Denkfehler. Einerseits gibt es den abstrakt Wert, andererseits die Darstellung, z.b. durch einen Stellenwertsystem wie das Binär- und Dezimalsystem oder was auch immer (Strichliste, römische Ziffern, etc.).
    Datentypen wie int, long, float etc. speichern den Wert; wie das intern aussieht ist eine andere Frage.



  • Das musst du mir grad nochmal näher erklären

    das versteh ich grad ned, worauf du hinaus willst

    der erste algo funzt ned, wenn ne 0 vorne ist
    und deiner will ein string, das bekomm ich ned hin



  • Zahlen die mit 0 beginnen machen eigentlich keinen Sinn daher markiert man dadurch eine Zahl zur Basis 8 (http://en.cppreference.com/w/cpp/language/integer_literal). Das Problem ist daher nicht im Algorithmus sondern wie du deine Zahlen eingibst. Welchen Sinn hat die ganze Sache eigentlich? Woher kommen deine Zahlen? Wenn du einfach nur binäre Zahlen im Quellcode eingeben möchtest gibt es dafür auch eine Schreibweise (Erst seit C++14 können aber viele Compiler schon länger):

    unsigned int a = 0b1000101;
    cout << a << endl; // Gibt 69 aus
    

    Du musst bedenken, dass Variablen wie int im Speicher immer binär abgelegt sind und nur zur Anzeige in dezimale/hexazimale oder was auch immer Schreibweise konvertiert werden.



  • hi sebi707,

    ja das ist mir schon klar. 😃 😃

    ich bekomme über einen CAN Bus binäre Daten als unsigned int.
    Daher muss ich irgendwas finden, um es umzurechnen.

    dieses Unsigned int kann natürlich so aussehen: 001110



  • EmbSofti schrieb:

    ich bekomme über einen CAN Bus binäre Daten als unsigned int.
    Daher muss ich irgendwas finden, um es umzurechnen.

    Warum muss man da was umrechnen? Schreib die binären Daten einfach wieder in ein unsigned int und fertig? Oder wie verstehst du binäre Daten. Binäre Daten sind bei mir nicht ein unsigned int das in der Dezimaldarstellung nur Einsen und Nullen hat.



  • wenn ich einen int wert in einen int wert schreibe, kommt genau das gleiche raus, was in dem ersten int drinstand und wenn sogar ne null vorne ist, irgendeine zahl

    es geht darum, dass ich was berechnen muss und dafür benötige ich den dezimalen wert.

    ich bekomme aber nur vom CAN einen unsigned int wert, dessen inhalt aber eigentlich binär ist.

    der int wert ist z.b. int i = 0110;
    ich muss den aber interpretieren als i = 0b0110

    bsp:

    ich bekomme eine geschwindigkeit in km/h vom CAN
    Die CAN Daten sind ein 12 Bit unsigned int - z.b. 011011100101

    um die richtige reale geschwindigkeit auszurechnen, hab ich eine formel:

    Geschwindigkeit = 0.1 * (DEZ) [km/h]

    das habe ich mit allen werten, die ich bekomme - immer mit entsprechenden umrechnungsformel.

    aber um das rechnen zu können, brauche ich dieses int als dezimalzahl...



  • Wie gesagt ein int enthält einen Wert, keine Darstellung eines Wertes. Wenn es dir die Zahl 1000101 liefert, dann ist das ein Wert, welcher im Binärsystem dargestelllt ist. Du hast also einen abstrakten, unvorstellbaren Wert, welcher nur durch eine Darstellung wie z.B. im Binärsystem oder Dezimalsystem oder römische Ziffern oder Striche oder Schafe oder... dargestellt werden kann.



  • Wie verschickst du die Daten denn über CAN? Du verschickst doch sicher Bytes oder irgendwas? Dann brauchst du eigentlich überhaupt nichts umrechnen. Auf der Sender Seite steht irgendwas wie:

    unsigned int x;
    canSendBytes((char*)&x, sizeof(x));
    

    Und auf der Empfänger Seite:

    unsigned int x;
    canRecvBytes((char*)&x, sizeof(x));
    

    Siehe dazu auch aktuell diesen Thread.



  • @EmbSofti
    int ist intern immer binär.
    Es kann höchstens noch sein dass das genaue Format nicht passt (z.B. Endianness, ones-complement vs. twos-complement).

    Ich vermute dir fehlt da noch ein bisschen das grundlegende Verständnis für Bits und Bytes und wie das ganze mit C, C++ etc. zusammenspielt.



  • Oha ... da hab ich ja richtig geraten.

    Dann vergiss aber nicht den Entwickler zu schlagen, der DAS verbrochen hat!!
    Eine binäre Zahl in einem Integerwert darstellen ... das würde ich mich ja noch nichtmal trauen am 1. April einzubauen! 🤡



  • EmbSofti schrieb:

    wenn ich einen int wert in einen int wert schreibe, kommt genau das gleiche raus, was in dem ersten int drinstand und wenn sogar ne null vorne ist, irgendeine zahl

    Integer Literale mit 0 vorn dran sind in C und C++ Oktalzahlen.
    Also 07 ist 7, 08 und 09 gibt's nicht und 010 ist 8.

    ----

    Falls du wirklich eine Binärzahl bekommst deren Dezimaldarstellung als Binärdarstellung reinterpretiert werden muss...

    #include <iostream>
    
    unsigned int FuckedUpToNormal(unsigned int fuckedUpNumber)
    {
    	unsigned int normalNumber = 0;
    	unsigned int bitValue = 1;
    	while (fuckedUpNumber != 0)
    	{
    		if ((fuckedUpNumber % 10) != 0)
    			normalNumber += bitValue;
    		fuckedUpNumber /= 10;
    		bitValue *= 2;
    	}
    	return normalNumber;
    }
    
    int main()
    {
    	unsigned int fuckedUpNumber = 1101; // "13"
    	std::cout << FuckedUpToNormal(fuckedUpNumber);
    	return 0;
    }
    


  • Mal am Rande:

    Kann es vielleicht sein, dass wir hier über BCD reden?



  • Hallo,

    nein es ist kein BCD

    Es ist genau das, was hustbaer meinte.

    und der algo funzt für meine bedürfnisse

    vielen dank 👍 👍 👍 👍



  • [quote="EmbSofti"Es ist genau das, was hustbaer meinte.

    und der algo funzt für meine bedürfnisse[/quote]
    Genau so einen Algo habe ich doch hier schon in meiner zweiten Antwort gepostet. Aber dann fing die Diskussion an mit Zahlen die mit einer 0 beginnen...



  • richtig,

    aber bei dem algo von hustbaer funktioniert auch, wenn ne Null vorne ist.

    hab aber inzwischen auch selbst ein algo geschrieben der über die oktalen das binäre ins dezimale umrechnet.



  • EmbSofti schrieb:

    aber bei dem algo von hustbaer funktioniert auch, wenn ne Null vorne ist.

    Das nennst du funktionieren?

    unsigned int fuckedUpNumber = 1101;
      unsigned int fuckedUpNumberOct = 01101;
      std::cout << FuckedUpToNormal(fuckedUpNumber);  // 13
      std::cout << FuckedUpToNormal(fuckedUpNumberOct);  // 7
    

    So ein Algorithmus kann gar nicht vernünftig funktionieren wenn man einfach eine 0 vorstellt. Man müsste schon die Zahl analysieren ob diese in der dezimal oder oktalen Darstellung nur aus Einsen und Nullen bestehen und dann entsprechend immer Modulo 8 rechnen statt 10, aber ein solches Format wäre erst recht fucked up (bin mir nichtmal sicher ob das eindeutig ist).


Anmelden zum Antworten