用C语言将阿拉伯数字（长整型）转换为单词

我想把一个数字，比如说，1024或2345787654转换成英语单词，这样对于1024，它就可以打印出1024等等

然而，我的代码给了我分段错误。我试图用

gdb

运行它，但它表明问题出在

my_strcat

函数中。但是，我认为这个函数没有任何问题。请帮忙

#include <stdlib.h>
#include <string.h>

const char *digits[] = { NULL, "one ", "two ", "three ", "four ", "five ", "six ", "seven ", "eight ", "nine " };
const char *tens[] = { NULL, "ten ", "twenty ", "thirty ", "forty ", "fifty ", "sixty ", "seventy ", "eighty ", "ninety " };
const char *teens[] = { "ten ", "eleven ", "twelve ", "thirteen ", "fourteen ", "fifteen ", "sixteen ", "seventeen ", "eighteen ", "nineteen " };
const char *scales[] = { "", "thousand ", "million ", "billion " };

char *my_strcat ( char **dest, const char * src)
{
    char *tab = malloc ( sizeof ( char) * (strlen ( *dest) + strlen ( src) + 1));
    if ( NULL == tab)
        return NULL;
    strcpy ( tab, *dest);
    strcat ( tab, src);
    free ( *dest);
    *dest = malloc ( sizeof ( char) * ( strlen ( tab) + 1));
    strcpy ( *dest, tab);
    return tab;
}

char * LongToEnglish(unsigned long x)
{
    switch(x)
    {
    case 0:
        return "Zero";
    case 1:
        return "One";
    case 2:
        return "Two";
    case 3:
        return "Three";
    case 4:
        return "Four";
    case 5:
        return "Five";
    case 6:
        return "Six";
    case 7:
        return "Seven";
    case 8:
        return "Eight";
    case 9:
        return "Nine";
    case 10:
        return "Ten";
    case 11:
        return "Eleven";
    case 12:
        return "Twelve";
    case 13:
        return "Thirteen";
    case 14:
        return "Fourteen";
    case 15:
        return "Fifteen";
    case 16:
        return "Sixteen";
    case 17:
        return "Seventeen";
    case 18:
        return "Eighteen";
    case 19:
        return "Nineteen";
    case 20:
        return "Twenty";
    case 30:
        return "Thirty";
    case 40:
        return "Forty";
    case 50:
        return "Fifty";
    case 60:
        return "Sixty";
    case 70:
        return "Seventy";
    case 80:
        return "Eighty";
    case 90:
        return "Ninety";
    case 100:
        return "One Hundred";
    case 1000:
        return "One Thousand";
    case 1000000:
        return "One Million";
    case 1000000000:
        return "One Billion";
    }
    // less than 100
    for (long i = 1; i <= 9; i ++)
    {
        long j = i * 10;
        if ((x >= j) && (x < j + 10))
        {
            long r = x - j;

            if(r > 0)
                return my_strcat(my_strcat(*LongToEnglish(j), " "), LongToEnglish(r));
            else
                return my_strcat(*LongToEnglish(j), "");
        }
    }
    // less than 1000
    for (long i = 1; i <= 9; i ++)
    {
        long j = i * 100;
        if ((x >= j) && (x < j + 100))
        {
            long r = x - j;

            if(r > 0)
                return my_strcat(my_strcat(LongToEnglish(i), " Hundred "), LongToEnglish(r));
            else
                return my_strcat(LongToEnglish(i), " Hundred");
        }
    }
    // less than 10000
    for (long i = 1; i <= 9; i ++)
    {
        long j = i * 1000;
        if ((x >= j) && (x < j + 1000))
        {
            long r = x - j;
            if(r > 0)
                return my_strcat(my_strcat(LongToEnglish(i), " Thousand "), LongToEnglish(r));
            else
                return my_strcat(LongToEnglish(i), " Thousand");
        }
    }
    // Million
    for (long i = 1; i <= 9; i ++)
    {
        long j = i * 1000000;
        if ((x >= j) && (x < j + 1000000))
        {
            long r = x - j;
            if(r > 0)
                return my_strcat(my_strcat(LongToEnglish(i), " Million "), LongToEnglish(r));
            else
                return my_strcat(LongToEnglish(i), " Million");
        }
    }
    // Billion
    for (long i = 1; i <= 4; i ++)
    {
        long j = i * 1000000000;
        if ((x >= j) && (x < j + 1000000000))
        {
            long r = x - j;
            if(r > 0)
                return my_strcat(my_strcat(LongToEnglish(i), " Billion "), LongToEnglish(r));
            else
                return my_strcat(LongToEnglish(i), " Billion");
        }
    }
    // Divide the number into 3-digit groups from left to right
    char* output = "";
    long cnt = 0;
    while (x > 0)
    {
        long y = x % 1000;
        x /= 1000;
        if (y > 0)   // skip middle-chunk zero
        {
            char * t = "";
            if (cnt == 1) t = " Thousand ";
            if (cnt == 2) t = " Million ";
            if (cnt == 3) t = " Billion ";
            output = my_strcat(my_strcat(LongToEnglish(y), t), output);
        }
        cnt ++;
    }

    return (output);
}

char* numberToWords(int num)
{
    return LongToEnglish(num);
}

int main(int argc, char **argv)
{
    char *dst = NULL;
    dst = malloc ( sizeof ( char) * 10000000);

    unsigned long long n = 122334;
    dst = numberToWords(n);

    printf("%s", dst);
    free(dst);

    return 0;
}

#包括
#包括
常量字符*数字[]={NULL，“一”、“二”、“三”、“四”、“五”、“六”、“七”、“八”、“九”}；
const char*tens[]={NULL，“十”，“二十”，“三十”，“四十”，“五十”，“六十”，“七十”，“八十”，“九十”}；
const char*teents[]{“十”、“十一”、“十二”、“十三”、“十四”、“十五”、“十六”、“十七”、“十八”、“十九”}；
常量字符*标度[]={”、“千”、“百万”、“十亿”}；
char*my_strcat（char**dest，const char*src）
{
char*tab=malloc（sizeof（char）*（strlen（*dest）+strlen（src）+1））；
如果（空==制表符）
返回NULL；
strcpy（制表符，*dest）；
strcat（标签，src）；
免费（*dest）；
*dest=malloc（sizeof（char）*（strlen（tab）+1））；
strcpy（*目的地，选项卡）；
返回选项卡；
}
char*LongToEnglish（无符号长x）
{
开关（x）
{
案例0：
返回“零”；
案例1：
返回“一”；
案例2：
返回“二”；
案例3：
返回“三”；
案例4：
返回“四”；
案例5：
返回“五”；
案例6：
返回“六”；
案例7：
返回“七”；
案例8：
返回“八”；
案例9：
返回“九”；
案例10：
返回“十”；
案例11：
返回“十一”；
案例12：
返回“十二”；
案例13：
返回“十三”；
案例14：
返回“十四”；
案例15：
返回“十五”；
案例16：
返回“十六”；
案例17：
返回“十七”；
案例18：
返回“十八”；
案例19：
返回“十九”；
案例20：
返回“二十”；
案例30：
返回“三十”；
案例40：
返回“四十”；
案例50：
返回“五十”；
案例60：
返回“六十”；
案例70：
返回“七十”；
案例80：
返回“八十”；
案例90：
返回“九十”；
案例100：
返回“一百”；
案例1000：
返回“一千”；
案例1000000：
返回“一百万”；
案例100000000：
回报“十亿”；
}
//少于100
对于（长i=1；i=j）和（x0）
返回我的英语单词（我的英语单词（*LongToEnglish（j），“”），LongToEnglish（r））；
其他的
归还我的护照（*龙英语（j），“”）；
}
}
//不足1000
对于（长i=1；i=j）和&（x0）
归还我的护照（我的护照（龙英语（i），“百”），龙英语（r））；
其他的
退还我的strcat（龙英语（i），“100”）；
}
}
//少于10000
对于（长i=1；i=j）和（x0）
归还我的护照（我的护照（龙英语（i），“千”），龙英语（r））；
其他的
退还我的现金（龙腾英语（i），“千”）；
}
}
//百万
对于（长i=1；i=j）和&（x0）
返回我的简历（我的简历（LongToEnglish（i），“百万”），LongToEnglish（r））；
其他的
返还我的现金（龙腾英语（i），“百万”）；
}
}
//十亿
对于（长i=1；i=j）和（x0）
返回我的字符串（我的字符串（LongToEnglish（i），“十亿”），LongToEnglish（r））；
其他的
归还我的strcat（龙英语（i），“十亿”）；
}
}
//将数字从左到右分成三位数组
字符*输出=”；
长cnt=0；
而（x>0）
{
长y=x%1000；
x/=1000；
如果（y>0）//跳过中间块零
{
char*t=“”；
如果（cnt==1）t=“千”；
如果（cnt==2）t=“百万”；
如果（cnt==3）t=“十亿”；
输出=my_strcat（my_strcat（LongToEnglish（y），t），输出）；
}
cnt++；
}
返回（输出）；
}
字符*numberToWords（int-num）
{
返回龙涛英语（num）；
}
int main（int argc，字符**argv）
{
char*dst=NULL；
dst=malloc（sizeof（char）*10000000）；
无符号长n=122334；
dst=数字字（n）；
printf（“%s”，dst）；
免费（dst）；
返回0；
}

我只告诉你一个问题，你的代码中还有其他问题。当在

main

中输入

n=3

时，

numberToWords

返回

“三个”

，您尝试调用

free（“三个”）

，等等

---

有时，您会返回一个静态字符串，并尝试在这种情况下释放它。

此任务适用于数千人的组，但始终相同。所以你可以做得简单得多。 字符串处理可能已优化

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const char *digits[] = { NULL, "one ", "two ", "three ", "four ", "five ", "six ", "seven ", "eight ", "nine ", "ten ", "eleven ", "twelve ", "thirteen ", "fourteen ", "fifteen ", "sixteen ", "seventeen ", "eighteen ", "nineteen " };
const char *tens[] = { NULL, "ten ", "twenty ", "thirty ", "forty ", "fifty ", "sixty ", "seventy ", "eighty ", "ninety " };
const char *scales[] = { "", "thousand ", "million ", "billion " };

char *long2words(long x, int grp) {
    char *buf = malloc(4096), *bp;    
    int e,t,h;

    *buf='\0';
    e = x%10;
    t = (x/10)%10;
    h = (x/100)%10;
    x /=1000;
    if(x!=0) {
        strcat(buf, bp=long2words(x,grp+1));
        free(bp);
    }
    if(h!=0) {
        strcat(buf, digits[h]);
        strcat(buf,"hundred ");
    }
    if(t<2) strcat(buf, digits[t*10+e]);
    else {
        strcat(buf, tens[t]);
        strcat(buf, digits[e]);
    }
    strcat(buf, scales[grp]);

    return buf;
}
int main()
{
    printf(long2words(102410241024,0));

    return 0;
}

#包括
#包括
#包括
常量字符*数字[]={NULL，“一”，“二”，“三”，“四”，“五”，“六”，“七”，“八”，“九”，“十”，“十一”，“十二”，“十三”，“十四”，“十五”，“十六”，“十七”，“十八”，“十九”}；
const char*tens[]={NULL，“十”，“二十”，“三十”，“四十”，“五十”，“六十”，“七十”，“八十”，“九十”}；
常量字符*标度[]={”、“千”、“百万”、“十亿”}；
char*long2words（长x，int-grp）{
char*buf=malloc（4096），*bp；
int e，t，h；
*buf='\0'；
e=x%10；