⑴ c語言編寫程序，從鍵盤輸入一個二進制正整數，輸出其對應的十進制數
問題大著呢，你只返回了一個數而已，應該返回一個數組 #include<stdio.h> void main() { void fun(int m,int *j,int c[]); int m; int i; int c[100]={0};//用來裝二進制數 int count = 0;//用來統計有效位數 printf("輸入一個十進制整數:\n"); scanf("%d",&m); fun(m,&count,c); for(i = 0; i < count; i++) printf("%d",c[i]); printf("\n"); } void fun(int m,int *j,int c[]) { int a[100],n,i,k=0; for(i=0;m>0;i++) { n=m%2; m=m/2; a[i]=n; *j=*j+1; } for(i=*j-1;i>=0;i--) { c[k++]=a[i]; } }
⑵ c語言的二進制數值如何直接輸出
1、首先打開vc6.0, 新建一個項目。
⑶ 用C語言編程,輸入任意十進制數輸出其相應的二進制數
把10進制數分解成2的冪,如X=2^n+2^(n-1)......+2^2+2^1+2^0,把公式中的2換成,則公式變成Z=10^n+10^(n-1)......+10^2+10^1+10^0
上式中,X是10進制,Z則是二進制
例子,把13換成2進制
13=2^3+2^2+0^1+2^0
把上式中的2換成10,則
Z=10^3+10^2+0^1+10^0
=1000+100+0+1=1101
也就是說,13換成2進製表是1101
⑷ 如何在c語言中輸出二進制數
可以用 %x格式 輸出16進制數，16進制一位拉4位，按8421分布，就是2進制數。1個位元組正好用2位16進製表示，轉為8位2進制。
⑸ 輸入一個十進制整數,輸出其對應的二進制數，用C語言的函數知識。
＃include＜stdio．h＞
int main（）
｛
int i，j，n，m＝－1，a［16］；
printf（＂請輸入十進制數＂）；
scanf（＂％d＂，＆n）；
while（n！＝0）
｛
i＝n％2；
a［＋＋m］＝i；
n＝n／2；
｝
for（j＝m；j＞＝0；j－－）
printf（＂％d＂，a［j］）；
return0；
｝
(5)c語言怎麼輸出其對應的二進制數擴展閱讀：
main函數用法
1、C++中的main函數
C++繼承了C語言的大部分特性，因此保留了「程序總是從main函數開始執行，且總是默認從main函數的return語句或結尾處結束運行」這一傳統，但是要注意，C++中的main函數要想作為程序執行的出入口，必須寫在全局(Global)范圍，
不能寫成某個結構體或某個類的成員。雖然main函數可以作為結構體或者類的成員函數，但相應地會失去作為程序出入口的功能。
C++中全局main函數的書寫格式與C語言完全相同，功能也完全相同，且同一C++程序同樣只能有一個全局main函數。
2、Java中的main函數
Java同樣是以main函數作為程序執行出入口的，但Java作為「更純潔」的面向對象語言，它的main函數與C/C++有很大的不同。
首先，返回值的概念淡化，在Java Application中main不允許返回值，因此int main是被禁止的，必須使用void main，int main僅限在JavaBean中使用。
其次，Java中所有的函數必須屬於類，沒有什麼全局函數一說，因此main函數不能是全局成員，必須是某個類的成員。
第三，由於main函數變成了類的成員函數，因此要想直接被系統調用，還必須使用public static使其成為靜態函數並具有公開許可權。
第四，main函數的參數被簡化，只需要提供字元串數組即可，不需要提供參數個數(這是由於Java的數組具有下標檢查功能的原因)
Java Application中的main函數一般格式如下(類名可以自定義，但保存為Java源碼時，主文件名必須與類名相同，否則可能無法運行)
public class MainDemo{
public static void main(String[]args){
//TODO:在此處寫入主函數的內容
}
}
Java Applet的運行機制與Java Application完全不同，因此不需要main函數
3、C#中的main函數
C#中的main函數與Java大同小異，同樣必須是類成員，同樣使用字元串數組作唯一參數，同樣是靜態函數，同樣的void main，
與之不同的是：main的首字母變成了大寫，即"Main函數「，且是否限定為public級別已經無所謂了(默認沒有public，但某些場合可能還是需要public)
另外，需要注意的是，C#中不再有」類名必須與主文件名同名「的限制，即使類名不和主文件名相同，程序照樣可以運行。
C#應用程序中的main函數默認是這樣的(注意main的首字母已是大寫)
C#和C/C++、java不同的是C#不在拘泥於必須從main()函數開始執行，C#是屬於事件觸發。
class Program{
static void Main(string[]args){
⑹ 輸入一個字元,輸出該字元對應的二進制 用C語言怎麼編
是對應的ASC碼的二進制吧？
char a;int b;int c[20];int i=0;
scanf("%c",&a);
b=a;
while(b)
{
c[i++]=b%2;
b/=2;
}
i-=1;
for(;i>=0;i--)
{
printf("%d",c[i]);
}
⑺ C語言中怎樣輸出一個二進制的數
//我們用按位運算符:右移>>和按位運算符與^，這兩個功能就可以實現。
#include<stdio.h>
voidprintBinary(intnumber);//這是聲明一個自定義的函數，讓編譯器知道我們造了一個這么個函數，功能：將整數以二進制形式輸出。
intmain()
{
printBinary(22);//括弧裡面可以填上你要輸出的整數，比如要輸出22的二進制形式
return0;
}
voidprintBinary()//自定義一個函數printBinary
{
inttemp=sizeof(number)-1;//定義一個變數：如果你的編譯器是32位的，也就是inttemp=31；
while（temp>=0）//temp是循環的次數，不需要糾結判斷是>=還是>,寫完之後檢驗一下就知道哪個對了。
intvalue=number>>temp^1;//a>>temp。temp移動後，是把這個整數的二進制形式中最後一位，依次與1進行按位與運算。假如temp=31，就是把這個整數的二進制形式右移31位，只剩下了這個整數的二進制形式的開頭第一個數字，然後與1進行按位與運算。真則為1，假則為0。
printf("%d",value);//每次輸出整數的二進制形式的一個數字，從開頭開始輸出。.
temp--；//按位右移循環，直到把整數內存中所有的位移完畢。從內存中二進制形式的第一位開始。
}
⑻ C語言：鍵盤輸入一個十進制整數，輸出其對應的二進制、三進制、四進制……十六進制數值。
#defineN"0123456789ABCDEF"
#include<stdio.h>
voidchange(intx,intn,char*p){
chartmp[100];//臨時存放轉換數
inti,total=0;
while(x){
tmp[total++]=N[x%n];
x/=n;
}
for(i=total-1;i>=0;i--){
p[total-1-i]=tmp[i];
}
if(total==0){
p[0]='0';
p[1]=0;
}
else
p[total-1-i]=0;
}
intmain()
{
chars[100];//用於存放轉換的進制的數
inti,x;
printf("把一個數轉換成234...16進制數 ");
scanf("%d",&x);
for(i=2;i<=16;i++){
change(x,i,s);
printf("轉換成%d進制是：%s ",i,s);
}
}
⑼ C編程 實現輸入一個正整數，輸出其對應的二進制數。
1。//實用點
#include <stdio.h>
typedef unsigned char byte;
void ShowBit(byte x, int n)
{
if (--n) ShowBit(x>>1, n);
printf("%d", x%2);
}
int main()
{
byte x = 0x6A;
ShowBit(x, 8);
return 0;
}
2。//容易點
#include <stdio.h>
int main(void) {
struct bits {
unsigned char b8 :1,
b7 :1,
b6 :1,
b5 :1,
b4 :1,
b3 :1,
b2 :1,
b1 :1;
};
union uchar {
struct bits chbits;
unsigned char ch;
} mychar;
printf("Enter a character: ");
scanf("%c", &mychar.ch);
printf("Binary representation of the character %c : %d%d%d%d%d%d%d%d\n", mychar.ch,
mychar.chbits.b1, mychar.chbits.b2, mychar.chbits.b3,
mychar.chbits.b4, mychar.chbits.b5, mychar.chbits.b6,
mychar.chbits.b7, mychar.chbits.b8);
return 0;
}
3.微軟標准答案
////////////////////////////////
static void __cdecl xtoa (
unsigned long val,
char *buf,
unsigned radix,
int is_neg
)
{
char *p; /* pointer to traverse string */
char *firstdig; /* pointer to first digit */
char temp; /* temp char */
unsigned digval; /* value of digit */
p = buf;
if (is_neg) {
/* negative, so output '-' and negate */
*p++ = '-';
val = (unsigned long)(-(long)val);
}
firstdig = p; /* save pointer to first digit */
do {
digval = (unsigned) (val % radix);
val /= radix; /* get next digit */
/* convert to ascii and store */
if (digval > 9)
*p++ = (char) (digval - 10 + 'a'); /* a letter */
else
*p++ = (char) (digval + '0'); /* a digit */
} while (val > 0);
/* We now have the digit of the number in the buffer, but in reverse
order. Thus we reverse them now. */
*p-- = '\0'; /* terminate string; p points to last digit */
do {
temp = *p;
*p = *firstdig;
*firstdig = temp; /* swap *p and *firstdig */
--p;
++firstdig; /* advance to next two digits */
} while (firstdig < p); /* repeat until halfway */
}
/* Actual functions just call conversion helper with neg flag set correctly,
and return pointer to buffer. */
char * __cdecl _itoa (
int val,
char *buf,
int radix
)
{
if (radix == 10 && val < 0)
xtoa((unsigned long)val, buf, radix, 1);
else
xtoa((unsigned long)(unsigned int)val, buf, radix, 0);
return buf;
}
char * __cdecl _ltoa (
long val,
char *buf,
int radix
)
{
xtoa((unsigned long)val, buf, radix, (radix == 10 && val < 0));
return buf;
}
char * __cdecl _ultoa (
unsigned long val,
char *buf,
int radix
)
{
xtoa(val, buf, radix, 0);
return buf;
}
#ifndef _NO_INT64
static void __stdcall x64toa ( /* stdcall is faster and smaller... Might as well use it for the helper. */
unsigned __int64 val,
char *buf,
unsigned radix,
int is_neg
)
{
char *p; /* pointer to traverse string */
char *firstdig; /* pointer to first digit */
char temp; /* temp char */
unsigned digval; /* value of digit */
p = buf;
if ( is_neg )
{
*p++ = '-'; /* negative, so output '-' and negate */
val = (unsigned __int64)(-(__int64)val);
}
firstdig = p; /* save pointer to first digit */
do {
digval = (unsigned) (val % radix);
val /= radix; /* get next digit */
/* convert to ascii and store */
if (digval > 9)
*p++ = (char) (digval - 10 + 'a'); /* a letter */
else
*p++ = (char) (digval + '0'); /* a digit */
} while (val > 0);
/* We now have the digit of the number in the buffer, but in reverse
order. Thus we reverse them now. */
*p-- = '\0'; /* terminate string; p points to last digit */
do {
temp = *p;
*p = *firstdig;
*firstdig = temp; /* swap *p and *firstdig */
--p;
++firstdig; /* advance to next two digits */
} while (firstdig < p); /* repeat until halfway */
}
/* Actual functions just call conversion helper with neg flag set correctly,
and return pointer to buffer. */
char * __cdecl _i64toa (
__int64 val,
char *buf,
int radix
)
{
x64toa((unsigned __int64)val, buf, radix, (radix == 10 && val < 0));
return buf;
}
char * __cdecl _ui64toa (
unsigned __int64 val,
char *buf,
int radix
)
{
x64toa(val, buf, radix, 0);
return buf;
}
#endif /* _NO_INT64 */
/////////////////////////////
例：
#include <stdio.h>
void main( void )
{
char buffer[20];
int i = 3445;
long l = -344115L;
unsigned long ul = 1234567890UL;
_itoa( i, buffer, 10 );
printf( "String of integer %d (radix 10): %s\n", i, buffer );
_itoa( i, buffer, 16 );
printf( "String of integer %d (radix 16): 0x%s\n", i, buffer );
_itoa( i, buffer, 2 );
printf( "String of integer %d (radix 2): %s\n", i, buffer );
_ltoa( l, buffer, 16 );
printf( "String of long int %ld (radix 16): 0x%s\n", l,
buffer );
_ultoa( ul, buffer, 16 );
printf( "String of unsigned long %lu (radix 16): 0x%s\n", ul,
buffer );
}
LZ給分