c语言题目，有点难度，牛人进来看看
假如C库中没有_itot64这个将一个64位的整数转化为字符串的函数，给你一个_itot32()函数，该函数可以将一个32位的整数转化为字符串，原型如下：
TCHAR *_itot32(_int32 value, //要转化的32位的整型数
TCHAR *str, //要输出的字符串
int32 radix //要转化的进制
)备注：_int32 就是平常的int型 _int64只64位的整型数
#ifdef _UNICODE
Typedef wstring tstring
#else
Typedef string tstring
TCHAR *itot64(unsigned _int64 i)
{
}
#end
[解决办法]
TCHAR *itot64(unsigned _int64 i)
{
int iHo,iLo;
iHod=i / 4294967296 ; //2^32
iLo=i % 4294967296 ;
_itot32();.....
}
[解决办法]
我想的可能简单了,这样成不,菜鸟答:
TCHAR *itot64(unsigned _int64 i,TCHAR *str)
{
assert(str!=NULL);
_int32 intLow,intHigh;
TCHAR* pTemp;
pTemp=(TCHAR*)malloc(256*sizeof(TCHAR));
intLow=(_int32)i;
intHigh=(_int32)(_int64> > 32);
strcat(str,_itot32(intHigh,pTemp,10));
return strcat(str,_itot32(intLow,pTemp,10));
}
[解决办法]
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;
}
[解决办法]
void itot64(unsigned __int64 i, int radix)
{
unsigned __int64 a = i;
__int64 m;
char tmp[100], *p=tmp;
if(abs(radix)> 1 && !(a <0 && radix> 0))
{
if(a!=0)
{
while(a!=0)
{
m=a/radix;
*p=a-m*radix;
if(*p <0 && radix <0)
{
*p=*p+abs(radix);m++;
}
p++;
a=m;
}
for (m=p-tmp-1;m> =0;m--)
{
if(tmp[m] > 9)
{
printf( "%c ",55+tmp[m]);
}
else
{
printf( "%d ",tmp[m]);
}
}
}
else
{
printf( "0 ");
}
printf( " (base %d)\n ",radix);
}
else
{
printf( "input error!\n ");
}
}
为了比较统一，在这个函数里加了个进制参数，由于是用来调试的，所以加了很多printf
楼主可以根据自己的需要再重新封装
上面这个是8字节数任意进制转换！
[解决办法]
用数学方法将64位数字分成3个可以用32位表示的数据分别转换之后再串起来
TCHAR *itot64(unsigned _int64 i)
{
_int32 j,k,l;
TCHAR *str= 24*(TCHAR *)malloc(sizeof(TCHAR));
TCHAR temp[10];
j=i%1000000000;
k=(i/1000000000)%100;
l=i/100000000000;
itot32(j,str,10);
itot32(k,temp,10);
strcat(str,temp);
itot32(l,temp,10);
strcat(str,temp);
return str;
}
[解决办法]
mark
[解决办法]
大家看看这样可以吗?
TCHAR *itot64(unsigned _int64 i)
{
char str[8];
unsigned _int64 a;
a = i;
str[0] = a> > 56;
str[1] = a> > 48;
str[2] = a> > 40;
str[3] = a> > 32;
str[4] = a> > 24;
str[5] = a> > 16;
str[6] = a> > 8;
str[7] = a;
return a;
}
[解决办法]
TCHAR *itot64(unsigned _int64 i)
{
unsigned int nLow = (unsigned int)i;
unsigned int nHi= (unsigned int)(i> > 32);
char low[32]={0};
char hi[32] ={0};
static char str[64]={0};
memset(str,0,64);
_itot32( nLow,low,32 );
_itot32( nHi,hi,32);
int i = strlen(hi);
if(i > 1 ||(i == 1 && hi[0]!= '0 '))
{
int j = strlen(low);
memcpy(str,low,j);
memset(str+j, '0 ',32-j);
memcpt(str+32,hi,i);
}
else
{memcpy(str,low,j);
}
return str;
}