1.要将一个数字从十进制转成二进制并以MSB方式并且能选择以2 Bytes或4 Bytes方式输出~

不知道有没有更简易的写法~或是程式中有没有Bug?~

int DecToHex(int Array_start, unsigned int Source,unsigned char *Result, int How_Byte)//10进位转16进位(MSB)
{
    int TempTotalCount1=0, TempTotalCount2=0, TempTotalCount3=0,TempTotalCount4=0;
   
    if (How_Byte == 4)
    {
        if ((Source / 256) >= 1)
        {
            if ((Source / 65536) >= 1)
            {
                if ((Source / 16777216) >= 1)
                {
                    Result[Array_start + 3] = (Source / 16777216);        //最高位数字(最右)
                    TempTotalCount1 = Result[Array_start + 3];
                    Result[Array_start + 2] = ((Source / 65536) - (TempTotalCount1 * 256));   //次高位数字(右)
                    TempTotalCount2 = Result[Array_start + 2];
                    Result[Array_start + 1] = ((Source / 256) - (TempTotalCount1 * 65536) - (TempTotalCount2 * 256)); //次次高位数字(右)
                    TempTotalCount3 = Result[Array_start + 1];
                    Result[Array_start + 0] = ((Source / 1) - (TempTotalCount1 * 16777216) - (TempTotalCount2 * 65536)-(TempTotalCount3*256));//最低位数字(最左)       
                    TempTotalCount4 = Result[Array_start + 0];
                }
                else
                {
                    if (Array_start == 262704)
                    {
                        Result[262700] = 5;
                        Result[262704] = 5;
                        Result[262705] = 5;
                        Result[262706] = 5;
                        Result[262707] = 5;
                    }
                    Result[Array_start + 3] = 0;
                    Result[Array_start + 2] = (Source / 65536);
                    TempTotalCount2 = Result[Array_start + 2];
                    Result[Array_start + 1] = ((Source / 256) - (TempTotalCount2 * 256));
                    Result[Array_start] = (Source - (256 * (Source / 256)));
                }
            }
            else
            {
                Result[Array_start + 3] = 0;
                Result[Array_start + 2] = 0;
                Result[Array_start + 1] = (Source / 256);
                Result[Array_start] = (Source - (256 * (Source / 256)));
            }
        }
        else
        {
            Result[Array_start + 3] = 0;
            Result[Array_start + 2] = 0;
            Result[Array_start + 1] = 0;
            Result[Array_start] = Source;
        }
    }  
    else if (How_Byte == 2)
    {
        if ((Source / 256) >= 1)
        {
            Result[Array_start + 1] = (Source / 256);
            Result[Array_start] = (Source - (256 * (Source / 256)));
        }
        else
        {
            Result[Array_start + 1] = 0;
            Result[Array_start] = Source;
        }
    }
    else if (How_Byte == 1)
    {
        Result[Array_start] = Source;
    }

    Array_start++;
    return Array_start;
}

2.要将原本Ascii Code转成Binary Code并且在整段字符串(二进制)前加上该字符串(二进制)的长度

不知道有沒有更簡易的寫法~或是程式中有沒有Bug?

int StringToHex(int K_start, int K_end, int j_start, int flag, char **part1,unsigned char *TitleTemp)//字串转16进位码
{
    unsigned int m,j,n,S_len=0;
    int k;
    char *temp;

    j = j_start;    //TitleTemp的开始位址
    k=K_start;        //part1的开始位址

    for (k = K_start;k<=K_end;k++)    //part1的目前位址
    {
        m = 0;
        temp=part1[k];
        if (strcmp(temp," ") != 0)
        {
            if(flag!=1)
            {
                S_len = strlen(temp);
                TitleTemp[j] = S_len;
                for (n=j+1;n<=(j+1)+S_len-1;n++)
                {
                    TitleTemp[n] = (int)temp[m];
                    m = m + 1;
                }
                j=j+S_len+1;
            }
            else
            {
                TitleTemp[j] = (int)temp[0];
                j = j + 1;
            }
        }       
        else
        {
            TitleTemp[j] = 0;
            j = j + 1;
        }
    }

    j_start=j;
    return j;
}

3.要将原本MSB写法的二进制2Bytes或4Bytes长度字节计算出十进制的数字

不知道有沒有更簡易的寫法~或是程式中有沒有Bug?

unsigned int sum(int start,int end,unsigned char *TitleTemp)//MSB 2Bytes或4Bytes计算
{   
    unsigned int mode;
    long Number,Number1,Number2,Number3,Number4;

    Number=0,Number1=0,Number2=0,Number3=0,Number4=0;
    mode=end-start+1;

    if(mode==2)
    {
        long Number1=(long)TitleTemp[end]*256;
        Number1=Number1&0x0000ffff;
        long Number2=(long)TitleTemp[end-1]*1;
        Number2=Number2&0x000000ff;
        Number=Number1+Number2;
        return Number;
    }
    else if(mode==4)
    {
        long Number1=(long)TitleTemp[end]*16777216;
        Number1=Number1&0xffffffff;
        long Number2=(long)TitleTemp[end-1]*65536;
        Number2=Number2&0x00ffffff;
        long Number3=(long)TitleTemp[end-2]*256;
        Number3=Number3&0x0000ffff;
        long Number4=(long)TitleTemp[end-3]*1;
        Number4=Number4&0x000000ff;
        long Number=Number1+Number2+Number3+Number4;
        return Number;
    }
    return 0;
}

这诡异的参数都是什么

#include <stdio.h>
main()
{
    int a=305419896;
    int i, j, k, bytes=sizeof(a);
    printf("Dec:%d\n", a);
    char *b=(char *)&a;
    printf("Bin:");
    for (i=0; i<bytes; i++)
        printf("%x ", b[i]);
    printf("\n");

    int *bb=(int *)b;
    printf("(int) Hex:%x   Dec:%d\n", *bb,*bb);
    short int *cc=(short int *)b;
    printf("(short int) Hex:%x   Dec:%hd\n", *cc,*cc);
    printf("\n");
    for (i=0; i<bytes; i++)
    {
        k = 0;
        for (j=0; j<=i; j++)
            k += b[j]<<(j*8);
        printf("%dByte 0x%x\n", i+1,k);
    }
}

我要下星期一上班才能解释
目前手边没有VC6

楼主的思路没看太懂。关于2的整数次幂的乘法和除法，可以考虑用移位运算，结合位与运算等可以使程序看上去更清晰

不知道题主要做什么，就第一个函数，如果善用强制类型转换的话，应该不需要那么复杂，代码如下：
#include <stdio.h>
#include <stdlib.h>
int DecToHex(int Array_start, unsigned int Source,unsigned char *Result, int How_Byte)//10进位转16进位(MSB)
{
    unsigned int *p;
    p=(unsigned int*)(Result+Array_start);
    *p=Source;
    Array_start+=How_Byte;
    return Array_start;
}

void main()
{
    unsigned int i,s;
    unsigned char a[100];
    i=1234567;
    s=DecToHex(0,i,a,4);
    for(i=0;i<s;i++)printf("%u,",a[i]);
    printf("\n");
}

第一个函数的功能是 :
若为2bytes状况时，假设当10进制数字为100，则转出16进制 00 64 处理后到文档中写入变为 64 00
若为4bytes状况时，假设当10进制数字为100，则转出16进制 00 00 00 64 处理后到文档中写入变为 64 00 00 00

第三个函数的功能是 :
若为2bytes状况时，从文档读入资料为 64 00 时，能计算出十进制数字为100
若为4bytes状况时，从文档读入资料为 64 00 00 00 时，能计算出十进制数字为100

第二个函数的功能是 :
读入一段字符串举例若该字符串为"ASCII"则将之转为 05 41 53 43 49 49

#include <stdio.h>
main()
{
    char buf[10];
    int i;
        //第一个函数的功能是 :
        //若为2bytes状况时，假设当10进制数字为100，则转出16进制 00 64 处理后到文档中写入变为 64 00
        //若为4bytes状况时，假设当10进制数字为100，则转出16进制 00 00 00 64 处理后到文档中写入变为 64 00 00 00
    short int *p2B=(short int *)buf;
    *p2B = 100;
    printf("\n2bytes Dec:100 Bin:");
    for (i=0; i<sizeof(short int); i++)
        printf("%02x ", buf[i]);
    printf("\n4bytes Dec:100 Bin:");
    int *p4B=(int *)buf;
    *p4B = 100;
    for (i=0; i<sizeof(int); i++)
        printf("%02x ", buf[i]);
        //第二个函数的功能是 :
        //读入一段字符串举例若该字符串为"ASCII"则将之转为 41 53 43 49 49
    printf("\nString:ASCII Bin:");
    sprintf(buf, "%s", "ASCII");
    for (i=0; i<5; i++)
        printf("%02x ", buf[i]);
    printf("\n");
        // 第三个函数的功能是 :
        // 若为2bytes状况时，从文档读入资料为 64 00 时，能计算出十进制数字为100
        // 若为4bytes状况时，从文档读入资料为 64 00 00 00 时，能计算出十进制数字为100
    printf("\n2bytes Bin:64 00 Dec:");
    sprintf(buf, "%c%c", 0x64,0x00);
    p2B = (short int *)buf;
    printf("%hd", *p2B);
    printf("\n4bytes Bin:64 00 00 00 Dec:");
    sprintf(buf, "%c%c%c%c", 0x64,0x00,0x00,0x00);
    p4B = (int *)buf;
    printf("%d", *p4B);
}

很漂亮的基于内存的数据操作，学习了。
早知道就先借鉴你的做法再去尝试完成题目。
代码还是要发出来，不这样勇于交流是不能有长足的进步，望大家积极指点。

/*
1.要将一个数字从十进制转成二进制并以MSB方式并且能选择以2 Bytes或4 Bytes方式输出~
*/

#include <stdio.h>

int tenFOR2(char *a,int x);    
int tenFOR16(char *a,int x);
void listData(char *a,int i,int j);

int main(int argc, char **argv)
{
    char a[100] = {0};    //用一个数组保存,第一位为a[0],第二为a[1].例如16进制就等于a[0]->0,a[1]->1
    int x , i ,j = 0;
    printf("input data :");
    scanf("%d",&x);
    
    //二进制处理
    i = tenFOR2(a,x);    //把输入十进制数输出为二进制,返回数组数据的长度
    j = 2;
    listData(a,i,j);   //打印数组的元素数据,a数组,i数据长度,j为进制数
    
    //十六进制处理
    i = tenFOR16(a,x);
    j = 16;
    listData(a,i,j);
    return 0;
}

int tenFOR2(char *a,int x){
    //i用于for循环，n记录数据的位数，y用来位操作
    unsigned int i = 0 , n = 0 , y = 1 ;    
    
    //查出数据y有多少位
    do{
        n++;
        y<<=1;
    }while(y != 0);
    
    //一般32位，重新定义i并位移31位，得出1000 0000 0000 0000 数据
    y = 1<<(n-1);

    printf("二进制表现形式为：");
    //循环去位与并打印结果，同时记录位值到数组里
    for (i = 0;i < n;i++){
        y&x ? (a[i] = 1,printf("%c",'1')) : (a[i] = 0,printf("%c",'0'));    
        x<<=1;    //推掉z比较完了的那一位
        if (i%8 == 7){
            printf(" ");
        }
    };
    printf("\n");
    return n;    //返回数组的数据长度
}

int tenFOR16(char *a,int x){
    
    int i = 0;
    printf("十六进制数为：%03X\n",x);    //输出一下目标结果，用来对比测试

    //记录数据，a[0]为16进制的个位，a[1]为十六进制的第二位
    do{
        a[i] = x%16;
        x/=16;
        i++;
    }while(x > 0);
    return i;
}
    
//输出格式自行修改
void listData(char *a,int i,int j){
    int k;
    printf("保存在数组里的数据：");
    for (k = 0; k < i ; k++){
        
        if (j == 2 ){
            printf("%d",a[k]);
            if(k%8 == 7){
                printf(" ");
            }
        }
        
        if (j == 16){
            if (a[k] > 9){
                printf("%c",a[k]-10+'A');
            }else{
                printf("%d",a[k]);
            }
        }
        
    }
    printf("\n");
}

    也差太多了吧，居然能写得那么简单，MSB和LSB切换只需一行...

    0x64,0x00,0x00,0x00 只是这几个字写法的原理看不太懂