Ich habe ein 'einfaches' Programm geschrieben (es hat 30 Minuten gedauert), das die Dezimalzahl in eine Binärzahl umwandelt. Ich bin mir sicher, dass es einen viel einfacheren Weg gibt. Können Sie es mir zeigen? Hier ist der Code:
#include <iostream>
#include <stdlib.h>
using namespace std;
int a1, a2, remainder;
int tab = 0;
int maxtab = 0;
int table[0];
int main()
{
system("clear");
cout << "Enter a decimal number: ";
cin >> a1;
a2 = a1; //we need our number for later on so we save it in another variable
while (a1!=0) //dividing by two until we hit 0
{
remainder = a1%2; //getting a remainder - decimal number(1 or 0)
a1 = a1/2; //dividing our number by two
maxtab++; //+1 to max elements of the table
}
maxtab--; //-1 to max elements of the table (when dividing finishes it adds 1 additional elemnt that we don't want and it's equal to 0)
a1 = a2; //we must do calculations one more time so we're gatting back our original number
table[0] = table[maxtab]; //we set the number of elements in our table to maxtab (we don't get 10's of 0's)
while (a1!=0) //same calculations 2nd time but adding every 1 or 0 (remainder) to separate element in table
{
remainder = a1%2; //getting a remainder
a1 = a1/2; //dividing by 2
table[tab] = remainder; //adding 0 or 1 to an element
tab++; //tab (element count) increases by 1 so next remainder is saved in another element
}
tab--; //same as with maxtab--
cout << "Your binary number: ";
while (tab>=0) //until we get to the 0 (1st) element of the table
{
cout << table[tab] << " "; //write the value of an element (0 or 1)
tab--; //decreasing by 1 so we show 0's and 1's FROM THE BACK (correct way)
}
cout << endl;
return 0;
}
Übrigens ist es kompliziert, aber ich habe mein Bestes versucht.
edit - Hier ist die Lösung, die ich letztendlich verwendet habe:
std::string toBinary(int n)
{
std::string r;
while(n!=0) {r=(n%2==0 ?"0":"1")+r; n/=2;}
return r;
}
int value = (some value); for (int i = (sizeof(value)*8)-1; i <= 0; i--) { cout << (value & (1 << i)) ? '1' : '0'; } cout << endl;
std::string ToBinary(int decimal)
, dann wird es in Zukunft einfach sein :)Antworten:
std::bitset
hat eine.to_string()
Methode, die einstd::string
Halten einer Textdarstellung in Binärform mit einem Abstand von Null vorgibt.Wählen Sie die Breite des Bitsets nach Bedarf für Ihre Daten, z. B.
std::bitset<32>
um 32-Zeichen-Zeichenfolgen aus 32-Bit-Ganzzahlen zu erhalten.#include <iostream> #include <bitset> int main() { std::string binary = std::bitset<8>(128).to_string(); //to binary std::cout<<binary<<"\n"; unsigned long decimal = std::bitset<8>(binary).to_ulong(); std::cout<<decimal<<"\n"; return 0; }
BEARBEITEN: Bitte bearbeiten Sie meine Antwort für Oktal und Hexadezimal nicht. Das OP forderte ausdrücklich Decimal To Binary an.
quelle
itoa
: cplusplus.com/reference/cstdlib/itoastd::size_t
Das Folgende ist eine rekursive Funktion, die eine positive Ganzzahl verwendet und ihre Binärziffern an die Konsole druckt.
Aus Gründen der Effizienz schlug Alex vor,
printf()
das Ergebnis zu entfernen und im Speicher zu speichern. Je nach Speichermethode kann das Ergebnis umgekehrt werden./** * Takes a unsigned integer, converts it into binary and prints it to the console. * @param n the number to convert and print */ void convertToBinary(unsigned int n) { if (n / 2 != 0) { convertToBinary(n / 2); } printf("%d", n % 2); }
Credits an UoA ENGGEN 131
* Hinweis: Der Vorteil der Verwendung eines int ohne Vorzeichen besteht darin, dass es nicht negativ sein kann.
quelle
n
Parameter zu einem machen,unsigned int
da die Funktion für negative Zahlen nicht richtig funktioniert.printf
Anruf für jedes Bit ist ziemlich schrecklich. Das "hocheffizient" ist Sarkasmus, oder?char buf[CHAR_BIT*sizeof(unsigned)]
. Durchlaufen Sie die Schleife, während Sie die Bits in der Ganzzahl mit einer Shift + Maske durchlaufen.'0' + 1
ist'1'
für ASCII, UTF8 und jeden anderen vernünftigen Zeichensatz, sodass Sie'0' + (n&1)
eine Ziffer erhalten können.Mit std :: bitset können Sie eine Zahl in ihr Binärformat konvertieren.
Verwenden Sie das folgende Codefragment:
std::string binary = std::bitset<8>(n).to_string();
Ich habe dies beim Stackoverflow selbst gefunden. Ich hänge den Link an .
quelle
Eine ziemlich einfache Lösung zum Drucken von Binärdateien:
#include <iostream> using namespace std; int main() { int num,arr[64]; cin>>num; int i=0,r; while(num!=0) { r = num%2; arr[i++] = r; num /= 2; } for(int j=i-1;j>=0;j--){ cout<<arr[j]; } }
quelle
Nicht rekursive Lösung:
#include <iostream> #include<string> std::string toBinary(int n) { std::string r; while(n!=0) {r=(n%2==0 ?"0":"1")+r; n/=2;} return r; } int main() { std::string i= toBinary(10); std::cout<<i; }
Rekursive Lösung:
#include <iostream> #include<string> std::string r=""; std::string toBinary(int n) { r=(n%2==0 ?"0":"1")+r; if (n / 2 != 0) { toBinary(n / 2); } return r; } int main() { std::string i=toBinary(10); std::cout<<i; }
quelle
/=2
, oder dieunsigned
Division durch zwei ist nur eine Verschiebung. Sie können auch verwenden'0' + n%2
, um ein ASCII / UTF-8 0 oder 1 zu erhalten. Dies'1'
ist das nächste ASCII-Zeichen danach'0'
. Sie können also einfach hinzufügen, anstatt ein zu verwenden?:
. Sie können auch eine Schleifechar buf[sizeof(n)]
ausführen, anstatt ein Zeichen einzeln an eine Zeichenfolge anzuhängen.Hier sind zwei Ansätze. Der eine ähnelt Ihrem Ansatz
#include <iostream> #include <string> #include <limits> #include <algorithm> int main() { while ( true ) { std::cout << "Enter a non-negative number (0-exit): "; unsigned long long x = 0; std::cin >> x; if ( !x ) break; const unsigned long long base = 2; std::string s; s.reserve( std::numeric_limits<unsigned long long>::digits ); do { s.push_back( x % base + '0' ); } while ( x /= base ); std::cout << std::string( s.rbegin(), s.rend() ) << std::endl; } }
und der andere verwendet std :: bitset, wie andere vorgeschlagen haben.
#include <iostream> #include <string> #include <bitset> #include <limits> int main() { while ( true ) { std::cout << "Enter a non-negative number (0-exit): "; unsigned long long x = 0; std::cin >> x; if ( !x ) break; std::string s = std::bitset<std::numeric_limits<unsigned long long>::digits>( x ).to_string(); std::string::size_type n = s.find( '1' ); std::cout << s.substr( n ) << std::endl; } }
quelle
Eine
int
Variable ist nicht dezimal, sondern binär. Was Sie suchen, ist eine binäre Zeichenfolgendarstellung der Zahl, die Sie erhalten können, indem Sie eine Maske anwenden, die einzelne Bits filtert, und diese dann drucken:for( int i = sizeof(value)*CHAR_BIT-1; i>=0; --i) cout << value & (1 << i) ? '1' : '0';
Das ist die Lösung, wenn Ihre Frage algorithmisch ist. Wenn nicht, sollten Sie die Klasse std :: bitset verwenden , um dies für Sie zu erledigen:
bitset< sizeof(value)*CHAR_BIT > bits( value ); cout << bits.to_string();
quelle
Die Konvertierung von einer natürlichen Zahl in eine Binärzeichenfolge:
string toBinary(int n) { if (n==0) return "0"; else if (n==1) return "1"; else if (n%2 == 0) return toBinary(n/2) + "0"; else if (n%2 != 0) return toBinary(n/2) + "1"; }
quelle
Hier ist eine moderne Variante, die für
ints
verschiedene Größen verwendet werden kann.#include <type_traits> #include <bitset> template<typename T> std::enable_if_t<std::is_integral_v<T>,std::string> encode_binary(T i){ return std::bitset<sizeof(T) * 8>(i).to_string(); }
quelle
Sie möchten etwas tun wie:
cout << "Enter a decimal number: "; cin >> a1; cout << setbase(2); cout << a1
quelle
setbase
sind16
,8
und10
. Jeder andere Wert setzt das Basisfeld auf Null zurück (Dezimalausgabe und präfixabhängige Ausgabe). Siehe diese Referenz für weitere Details: std :: setbase - cpprefernce.comDEZIMAL BINÄR KEINE VERWENDETEN ARRAYS * von Oya:
Ich bin noch ein Anfänger, daher verwendet dieser Code nur Schleifen und Variablen xD ...
Hoffe du magst es. Dies kann wahrscheinlich einfacher gemacht werden als es ist ...
#include <iostream> #include <cmath> #include <cstdlib> using namespace std; int main() { int i; int expoentes; //the sequence > pow(2,i) or 2^i int decimal; int extra; //this will be used to add some 0s between the 1s int x = 1; cout << "\nThis program converts natural numbers into binary code\nPlease enter a Natural number:"; cout << "\n\nWARNING: Only works until ~1.073 millions\n"; cout << " To exit, enter a negative number\n\n"; while(decimal >= 0){ cout << "\n----- // -----\n\n"; cin >> decimal; cout << "\n"; if(decimal == 0){ cout << "0"; } while(decimal >= 1){ i = 0; expoentes = 1; while(decimal >= expoentes){ i++; expoentes = pow(2,i); } x = 1; cout << "1"; decimal -= pow(2,i-x); extra = pow(2,i-1-x); while(decimal < extra){ cout << "0"; x++; extra = pow(2,i-1-x); } } } return 0; }
quelle
char buffer[32]
Einstellungbuffer[i] = '0' + (tmp&1)
, um ein'0'
oder'1'
(ASCII / UTF-8-Zeichen) entsprechend dem niedrigen Bit von zu speicherntmp
. Danntmp >>= 1
nach rechts verschieben. Die Verwendung von Gleitkommazahlenpow
ist einfach verrückt, insbesondere für Zweierpotenzen.hier ein einfacher Konverter
std::string
als Container. es erlaubt einen negativen Wert.#include <iostream> #include <string> #include <limits> int main() { int x = -14; int n = std::numeric_limits<int>::digits - 1; std::string s; s.reserve(n + 1); do s.push_back(((x >> n) & 1) + '0'); while(--n > -1); std::cout << s << '\n'; }
quelle
Dies ist ein einfacheres Programm als je zuvor
//Program to convert Decimal into Binary #include<iostream> using namespace std; int main() { long int dec; int rem,i,j,bin[100],count=-1; again: cout<<"ENTER THE DECIMAL NUMBER:- "; cin>>dec;//input of Decimal if(dec<0) { cout<<"PLEASE ENTER A POSITIVE DECIMAL"; goto again; } else { cout<<"\nIT's BINARY FORM IS:- "; for(i=0;dec!=0;i++)//making array of binary, but reversed { rem=dec%2; bin[i]=rem; dec=dec/2; count++; } for(j=count;j>=0;j--)//reversed binary is printed in correct order { cout<<bin[j]; } } return 0; }
quelle
Es gibt in der Tat einen sehr einfachen Weg, dies zu tun. Wir verwenden eine rekursive Funktion, die im Parameter die Nummer (int) erhält. Es ist ziemlich leicht zu verstehen. Sie können auch andere Bedingungen / Variationen hinzufügen. Hier ist der Code:
int binary(int num) { int rem; if (num <= 1) { cout << num; return num; } rem = num % 2; binary(num / 2); cout << rem; return rem; }
quelle
#include "stdafx.h" #include<iostream> #include<vector> #include<cmath> using namespace std; int main() { // Initialize Variables double x; int xOct; int xHex; //Initialize a variable that stores the order if the numbers in binary/sexagesimal base vector<int> rem; //Get Demical value cout << "Number (demical base): "; cin >> x; //Set the variables xOct = x; xHex = x; //Get the binary value for (int i = 0; x >= 1; i++) { rem.push_back(abs(remainder(x, 2))); x = floor(x / 2); } //Print binary value cout << "Binary: "; int n = rem.size(); while (n > 0) { n--; cout << rem[n]; } cout << endl; //Print octal base cout << oct << "Octal: " << xOct << endl; //Print hexademical base cout << hex << "Hexademical: " << xHex << endl; system("pause"); return 0; }
quelle
#include <iostream> using namespace std; int main() { int a,b; cin>>a; for(int i=31;i>=0;i--) { b=(a>>i)&1; cout<<b; } }
quelle
HOPE YOU LIKE THIS SIMPLE CODE OF CONVERSION FROM DECIMAL TO BINARY #include<iostream> using namespace std; int main() { int input,rem,res,count=0,i=0; cout<<"Input number: "; cin>>input;`enter code here` int num=input; while(input > 0) { input=input/2; count++; } int arr[count]; while(num > 0) { arr[i]=num%2; num=num/2; i++; } for(int i=count-1 ; i>=0 ; i--) { cout<<" " << arr[i]<<" "; } return 0; }
quelle
std::string bin(uint_fast8_t i){return !i?"0":i==1?"1":bin(i/2)+(i%2?'1':'0');}
quelle
// function to convert decimal to binary void decToBinary(int n) { // array to store binary number int binaryNum[1000]; // counter for binary array int i = 0; while (n > 0) { // storing remainder in binary array binaryNum[i] = n % 2; n = n / 2; i++; } // printing binary array in reverse order for (int j = i - 1; j >= 0; j--) cout << binaryNum[j]; }
Siehe: - https://www.geeksforgeeks.org/program-decimal-binary-conversion/
oder mit Funktion: -
#include<bits/stdc++.h> using namespace std; int main() { int n;cin>>n; cout<<bitset<8>(n).to_string()<<endl; }
oder mit Linksverschiebung
#include<bits/stdc++.h> using namespace std; int main() { // here n is the number of bit representation we want int n;cin>>n; // num is a number whose binary representation we want int num; cin>>num; for(int i=n-1;i>=0;i--) { if( num & ( 1 << i ) ) cout<<1; else cout<<0; } }
quelle
In C ++ können Sie hierfür die Funktion itoa () verwenden. Diese Funktion konvertiert eine beliebige Dezimalzahl in eine Binär-, Dezimal-, Hexadezimal- und Oktalzahl.
#include<bits/stdc++.h> using namespace std; int main(){ int a; char res[1000]; cin>>a; itoa(a,res,10); cout<<"Decimal- "<<res<<endl; itoa(a,res,2); cout<<"Binary- "<<res<<endl; itoa(a,res,16); cout<<"Hexadecimal- "<<res<<endl; itoa(a,res,8); cout<<"Octal- "<<res<<endl;return 0; }
Es wird jedoch nur von bestimmten Compilern unterstützt.
Sie können auch sehen: itoa - C ++ Referenz
quelle
#include <iostream> #include <bitset> #define bits(x) (std::string( \ std::bitset<8>(x).to_string<char,std::string::traits_type, std::string::allocator_type>() ).c_str() ) int main() { std::cout << bits( -86 >> 1 ) << ": " << (-86 >> 1) << std::endl; return 0; }
quelle
Okay .. Ich bin vielleicht ein bisschen neu in C ++, aber ich bin der Meinung, dass die obigen Beispiele die Arbeit nicht ganz richtig machen.
Hier ist meine Sicht auf diese Situation.
char* DecimalToBinary(unsigned __int64 value, int bit_precision) { int length = (bit_precision + 7) >> 3 << 3; static char* binary = new char[1 + length]; int begin = length - bit_precision; unsigned __int64 bit_value = 1; for (int n = length; --n >= begin; ) { binary[n] = 48 | ((value & bit_value) == bit_value); bit_value <<= 1; } for (int n = begin; --n >= 0; ) binary[n] = 48; binary[length] = 0; return binary; }
@value = Der Wert, den wir überprüfen.
@bit_precision = Das am weitesten links stehende Bit, nach dem gesucht werden muss.
@Length = Die maximale Byteblockgröße. ZB 7 = 1 Byte und 9 = 2 Byte, aber wir stellen dies in Form von Bits dar, also 1 Byte = 8 Bits.
@binary = nur ein dummer Name, den ich gegeben habe, um das von uns eingestellte Zeichenfeld aufzurufen. Wir setzen dies auf statisch, damit es nicht bei jedem Aufruf neu erstellt wird. Um einfach ein Ergebnis zu erhalten und es anzuzeigen, funktioniert dies gut. Wenn Sie jedoch mehrere Ergebnisse auf einer Benutzeroberfläche anzeigen möchten, werden alle als letztes Ergebnis angezeigt. Dies kann durch Entfernen der statischen Aufladung behoben werden. Stellen Sie jedoch sicher, dass Sie die Ergebnisse löschen, wenn Sie damit fertig sind.
@begin = Dies ist der niedrigste Index, den wir überprüfen. Alles darüber hinaus wird ignoriert. Oder wie in der 2. Schleife gezeigt auf 0 gesetzt.
@first loop - Hier setzen wir den Wert auf 48 und addieren im Grunde eine 0 oder 1 zu 48 basierend auf dem Bool-Wert von (value & bit_value) == bit_value. Wenn dies wahr ist, wird das Zeichen auf 49 gesetzt. Wenn dies falsch ist, wird das Zeichen auf 48 gesetzt. Dann verschieben wir den bit_value oder multiplizieren ihn grundsätzlich mit 2.
@second loop - Hier setzen wir alle Indizes, die wir ignoriert haben, auf 48 oder '0'.
EINIGE BEISPIELE !!!
int main() { int val = -1; std::cout << DecimalToBinary(val, 1) << '\n'; std::cout << DecimalToBinary(val, 3) << '\n'; std::cout << DecimalToBinary(val, 7) << '\n'; std::cout << DecimalToBinary(val, 33) << '\n'; std::cout << DecimalToBinary(val, 64) << '\n'; std::cout << "\nPress any key to continue. . ."; std::cin.ignore(); return 0; } 00000001 //Value = 2^1 - 1 00000111 //Value = 2^3 - 1. 01111111 //Value = 2^7 - 1. 0000000111111111111111111111111111111111 //Value = 2^33 - 1. 1111111111111111111111111111111111111111111111111111111111111111 //Value = 2^64 - 1.
GESCHWINDIGKEITSTESTS
Antwort der ursprünglichen Frage: "Methode: toBinary (int);"
Ausführungen: 10.000, Gesamtzeit (Milli): 4701,15, durchschnittliche Zeit (Nanosekunden): 470114
Meine Version: "Methode: DecimalToBinary (int, int);"
// 64-Bit-Präzision verwenden.
Ausführungen: 10.000.000, Gesamtzeit (Milli): 3386, durchschnittliche Zeit (Nanosekunden): 338
// 1 Bit Präzision verwenden.
Ausführungen: 10.000.000, Gesamtzeit (Milli): 634, durchschnittliche Zeit (Nanosekunden): 63
quelle
#include <iostream> // x is our number to test // pow is a power of 2 (e.g. 128, 64, 32, etc...) int printandDecrementBit(int x, int pow) { // Test whether our x is greater than some power of 2 and print the bit if (x >= pow) { std::cout << "1"; // If x is greater than our power of 2, subtract the power of 2 return x - pow; } else { std::cout << "0"; return x; } } int main() { std::cout << "Enter an integer between 0 and 255: "; int x; std::cin >> x; x = printandDecrementBit(x, 128); x = printandDecrementBit(x, 64); x = printandDecrementBit(x, 32); x = printandDecrementBit(x, 16); std::cout << " "; x = printandDecrementBit(x, 8); x = printandDecrementBit(x, 4); x = printandDecrementBit(x, 2); x = printandDecrementBit(x, 1); return 0; }
Dies ist ein einfacher Weg, um die binäre Form eines Int zu erhalten. Gutschrift an learncpp.com. Ich bin mir sicher, dass dies auf verschiedene Arten verwendet werden kann, um zum gleichen Punkt zu gelangen.
quelle
Bei diesem Ansatz wird die Dezimalstelle in die jeweilige Binärzahl im Zeichenfolgenformat konvertiert. Der String-Rückgabetyp wird ausgewählt, da er einen größeren Bereich von Eingabewerten verarbeiten kann.
class Solution { public: string ConvertToBinary(int num) { vector<int> bin; string op; for (int i = 0; num > 0; i++) { bin.push_back(num % 2); num /= 2; } reverse(bin.begin(), bin.end()); for (size_t i = 0; i < bin.size(); ++i) { op += to_string(bin[i]); } return op; } };
quelle
Meine Art, Dezimal in C ++ in Binär umzuwandeln. Da wir aber mod verwenden, funktioniert diese Funktion auch bei hexadezimal oder oktal. Sie können auch Bits angeben. Diese Funktion berechnet weiterhin das niedrigstwertige Bit und platziert es am Ende der Zeichenfolge. Wenn Sie dieser Methode nicht so ähnlich sind, können Sie sie besuchen: https://www.wikihow.com/Convert-from-Decimal-to-Binary
#include <bits/stdc++.h> using namespace std; string itob(int bits, int n) { int c; char s[bits+1]; // +1 to append NULL character. s[bits] = '\0'; // The NULL character in a character array flags the end of the string, not appending it may cause problems. c = bits - 1; // If the length of a string is n, than the index of the last character of the string will be n - 1. Cause the index is 0 based not 1 based. Try yourself. do { if(n%2) s[c] = '1'; else s[c] = '0'; n /= 2; c--; } while (n>0); while(c > -1) { s[c] = '0'; c--; } return s; } int main() { cout << itob(1, 0) << endl; // 0 in 1 bit binary. cout << itob(2, 1) << endl; // 1 in 2 bit binary. cout << itob(3, 2) << endl; // 2 in 3 bit binary. cout << itob(4, 4) << endl; // 4 in 4 bit binary. cout << itob(5, 15) << endl; // 15 in 5 bit binary. cout << itob(6, 30) << endl; // 30 in 6 bit binary. cout << itob(7, 61) << endl; // 61 in 7 bit binary. cout << itob(8, 127) << endl; // 127 in 8 bit binary. return 0; }
Die Ausgabe:
0 01 010 0100 01111 011110 0111101 01111111
quelle
Ihre Lösung muss geändert werden. Die letzte Zeichenfolge sollte vor der Rückkehr umgekehrt werden:
std::reverse(r.begin(), r.end()); return r;
quelle
mit Bitmaske und bitweise und.
string int2bin(int n){ string x; for(int i=0;i<32;i++){ if(n&1) {x+='1';} else {x+='0';} n>>=1; } reverse(x.begin(),x.end()); return x; }
quelle
Unten finden Sie einen einfachen C-Code, der Binär in Dezimal und wieder zurück konvertiert. Ich habe es vor langer Zeit für ein Projekt geschrieben, bei dem das Ziel ein eingebetteter Prozessor war und die Entwicklungstools eine stdlib hatten, die für das Firmware-ROM viel zu groß war.
Dies ist generischer C-Code, der keine Bibliothek verwendet, weder die Division noch den Restoperator (%) (der bei einigen eingebetteten Prozessoren langsam ist), noch Gleitkomma verwendet, noch eine Tabellensuche verwendet emulieren Sie jede BCD-Arithmetik. Es wird der Typ verwendet
long long
, genauer gesagtunsigned long long
(oderuint64_t
). Wenn Ihr eingebetteter Prozessor (und der dazugehörige C-Compiler) keine 64-Bit-Ganzzahlarithmetik ausführen kann, ist dieser Code nicht für Ihre Anwendung geeignet. Ansonsten denke ich, dass dies C-Code in Produktionsqualität ist (möglicherweise nach dem Wechsellong
zuint32_t
undunsigned long long
zuuint64_t
). Ich habe dies über Nacht ausgeführt, um es für alle 2³² vorzeichenbehafteten Ganzzahlwerte zu testen, und es gibt keinen Fehler bei der Konvertierung in beide Richtungen.Wir hatten einen C-Compiler / Linker, der ausführbare Dateien generieren konnte, und wir mussten das tun, was wir ohne stdlib (was ein Schwein war) tun konnten . Also nein
printf()
nochscanf()
. Nicht einmal einsprintf()
nochsscanf()
. Aber wir hatten immer noch eine Benutzeroberfläche und mussten Basis-10-Zahlen in Binärzahlen und zurück konvertieren. (Wir haben auch unser eigenesmalloc()
Dienstprogramm und unsere eigenen transzendentalen mathematischen Funktionen zusammengestellt.)So habe ich es gemacht (das
main
Programm und die Aufrufe von stdlib waren da, um dieses Ding auf meinem Mac zu testen, nicht für den eingebetteten Code). Da einige ältere Entwicklungssysteme "int64_t
" und "uint64_t
" und ähnliche Typen nicht erkennen , werden die Typenlong long
undunsigned long long
verwendet und als dieselben angenommen. Undlong
wird mit 32 Bit angenommen. Ich denke, ich hätte estypedef
bearbeiten können.// returns an error code, 0 if no error, // -1 if too big, -2 for other formatting errors int decimal_to_binary(char *dec, long *bin) { int i = 0; int past_leading_space = 0; while (i <= 64 && !past_leading_space) // first get past leading spaces { if (dec[i] == ' ') { i++; } else { past_leading_space = 1; } } if (!past_leading_space) { return -2; // 64 leading spaces does not a number make } // at this point the only legitimate remaining // chars are decimal digits or a leading plus or minus sign int negative = 0; if (dec[i] == '-') { negative = 1; i++; } else if (dec[i] == '+') { i++; // do nothing but go on to next char } // now the only legitimate chars are decimal digits if (dec[i] == '\0') { return -2; // there needs to be at least one good } // digit before terminating string unsigned long abs_bin = 0; while (i <= 64 && dec[i] != '\0') { if ( dec[i] >= '0' && dec[i] <= '9' ) { if (abs_bin > 214748364) { return -1; // this is going to be too big } abs_bin *= 10; // previous value gets bumped to the left one digit... abs_bin += (unsigned long)(dec[i] - '0'); // ... and a new digit appended to the right i++; } else { return -2; // not a legit digit in text string } } if (dec[i] != '\0') { return -2; // not terminated string in 64 chars } if (negative) { if (abs_bin > 2147483648) { return -1; // too big } *bin = -(long)abs_bin; } else { if (abs_bin > 2147483647) { return -1; // too big } *bin = (long)abs_bin; } return 0; } void binary_to_decimal(char *dec, long bin) { unsigned long long acc; // 64-bit unsigned integer if (bin < 0) { *(dec++) = '-'; // leading minus sign bin = -bin; // make bin value positive } acc = 989312855LL*(unsigned long)bin; // very nearly 0.2303423488 * 2^32 acc += 0x00000000FFFFFFFFLL; // we need to round up acc >>= 32; acc += 57646075LL*(unsigned long)bin; // (2^59)/(10^10) = 57646075.2303423488 = 57646075 + (989312854.979825)/(2^32) int past_leading_zeros = 0; for (int i=9; i>=0; i--) // maximum number of digits is 10 { acc <<= 1; acc += (acc<<2); // an efficient way to multiply a long long by 10 // acc *= 10; unsigned int digit = (unsigned int)(acc >> 59); // the digit we want is in bits 59 - 62 if (digit > 0) { past_leading_zeros = 1; } if (past_leading_zeros) { *(dec++) = '0' + digit; } acc &= 0x07FFFFFFFFFFFFFFLL; // mask off this digit and go on to the next digit } if (!past_leading_zeros) // if all digits are zero ... { *(dec++) = '0'; // ... put in at least one zero digit } *dec = '\0'; // terminate string } #if 1 #include <stdlib.h> #include <stdio.h> int main (int argc, const char* argv[]) { char dec[64]; long bin, result1, result2; unsigned long num_errors; long long long_long_bin; num_errors = 0; for (long_long_bin=-2147483648LL; long_long_bin<=2147483647LL; long_long_bin++) { bin = (long)long_long_bin; if ((bin&0x00FFFFFFL) == 0) { printf("bin = %ld \n", bin); // this is to tell us that things are moving along } binary_to_decimal(dec, bin); decimal_to_binary(dec, &result1); sscanf(dec, "%ld", &result2); // decimal_to_binary() should do the same as this sscanf() if (bin != result1 || bin != result2) { num_errors++; printf("bin = %ld, result1 = %ld, result2 = %ld, num_errors = %ld, dec = %s \n", bin, result1, result2, num_errors, dec); } } printf("num_errors = %ld \n", num_errors); return 0; } #else #include <stdlib.h> #include <stdio.h> int main (int argc, const char* argv[]) { char dec[64]; long bin; printf("bin = "); scanf("%ld", &bin); while (bin != 0) { binary_to_decimal(dec, bin); printf("dec = %s \n", dec); printf("bin = "); scanf("%ld", &bin); } return 0; } #endif
quelle
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> void Decimal2Binary(long value,char *b,int len) { if(value>0) { do { if(value==1) { *(b+len-1)='1'; break; } else { *(b+len-1)=(value%2)+48; value=value/2; len--; } }while(1); } } long Binary2Decimal(char *b,int len) { int i=0; int j=0; long value=0; for(i=(len-1);i>=0;i--) { if(*(b+i)==49) { value+=pow(2,j); } j++; } return value; } int main() { char data[11];//最後一個BIT要拿來當字串結尾 long value=1023; memset(data,'0',sizeof(data)); data[10]='\0';//字串結尾 Decimal2Binary(value,data,10); printf("%d->%s\n",value,data); value=Binary2Decimal(data,10); printf("%s->%d",data,value); return 0; }
quelle