⑴ 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给分