整型数转换为汉字字符串

如：
123445 十二万三千四百四十五
234444 二十三万四千四百四十四

8 个解决方案

#1

以字符方式读入整形数字每一位存储到数组中，然后转化成对应的汉字输出

#2

#include <cstdlib>
#include <iostream>
#include <string>
#include <stack>
using namespace std;

// 浪费点内存，但是不易出错（变量cnt使用起来自然很多）。
string Unit[] = {"", "零", "拾", "百", "千", "万", "拾", "百", "千", "亿", "拾"};
string Num[] = {"", "一", "二", "三", "四", "五", "六", "七", "八", "九"};

void convert(int number) {
    // 将数字拆开，压入栈中，并用cnt记录位数
    stack<int> S;
    int cnt = 0;
    
    do {
        S.push(number % 10);
        ++cnt;
    } while (number /= 10);

    if (cnt > 10) {
        cout << "输入的数过大，此程序不能处理。";
        exit(0);
    }

    int cur = -1;
    while (!S.empty()) {
        cur = S.top();
        // 保证当亿、万位置数字为零时，能够输出这些单位
        if (!cur && cnt % 4 == 1) {
            cout << Unit[cnt]; // 输出单位
            --cnt;
            S.pop();
            continue ;
        }

        // 输出数字和单位
        if (cur) {
            cout << Num[cur];
            cout << Unit[cnt];
        }
        --cnt;
        S.pop();
    }
    cout << endl;
}

int main()
{
    // int型最多表示二十几亿。
    int number;
    while (cin >> number) {
        convert(number);
    }

    return 0;
}

引用 楼主 sundq12 的回复:

如：
123445 十二万三千四百四十五
234444 二十三万四千四百四十四

#3

200404

#4

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

typedef int bool;
#define TRUE 1
#define FALSE 0

void make_group_str( unsigned int value, char ** buffer, bool output0)
{
    static const char * units[] = {"", "十","百","千"};
    static const unsigned int unit_lens[] = {0, 2, 2, 2};
    static const char * nums[] = {"零","一","二","三","四","五","六","七","八","九"};
    static const unsigned int num_lens[] = { 2,2,2,2,2,2,2,2,2,2};


    assert(buffer && *buffer);
    assert(value < 10000 && value > 0);
    unsigned int i = 1;
    unsigned int temp = value;
    unsigned int base = 1;
    if(output0)//输出前导零，从4位数开始
    {
        base = 1000;
        i = 4;
    }
    else//不输出前导零，找到最高位
    {
        while( temp >= 10)
        {
            temp /=10;
            ++ i;
            base *= 10;
        }

    }
    while( i > 0)
    {
        --i;
        temp = value /base % 10;
        if( temp )
        {
            strcpy(*buffer, nums[temp]);
            *buffer += num_lens[temp];
            strcpy(*buffer, units[i]);
            *buffer +=  unit_lens[i];
            output0 = TRUE;//非零值后面的零要输出
        }
        else if( output0 )
        {
            strcpy(*buffer, nums[0]);
            *buffer += num_lens[0];
            output0=FALSE;//连续0只输出一个
        }
        base /= 10;
    }
    if(temp == 0)//结尾的零要去除
    {
        *buffer -= num_lens[0];
        **buffer = '\0';
    }
}

void make_chnum_str( unsigned int value, char * buffer )
{
    static const char * group_names[] = {"", "万","亿"};
    static const unsigned int gname_lens[] = {0, 2, 2};
    int i = 1;
    int base = 1;
    unsigned int temp = value;
    while( temp >= 10000)
    {
        temp /= 10000;
        ++i;
        base *= 10000;
    }
    bool output0 = FALSE;//最高组不输出前导0
    while( i > 0)
    {
        -- i;
        temp = value / base;
        make_group_str( temp, & buffer, output0 );
        strcpy( buffer, group_names[i]);
        buffer += gname_lens[i];

        value %= base;
        base /= 10000;
        output0 = TRUE;//后继组要输出前导0
    }
}

int main()
{
    int value;
    char buffer[40];//32整数的转换结果最多19个汉字,GBK编码只要39个字节就够了，还多定义了一个。
    while (scanf("%d", &value ))
    {
        make_chnum_str(value, buffer);
        printf("%s", buffer);
    }

    return 0;
}

四位数为一组，每组最后的零不输出，每组中间的零要输出，第二组起开始的零要输出，连续的零只输出一个。
应该是这个逻辑吧？小学学的，有点儿记不清了……

边界检查和数值大小检查（如果int是64位的话需要）没有写，需要的话自己加上。

#5

#include <cstdlib>
#include <iostream>
#include <string>
 
using namespace std;
string digit[] = {"","十","百","千","万","十","百","千","亿","十","百","千"}; 
string num[] = {"零","一","二","三","四","五","六","七","八","九"};
//当出现数字为零时此程序不可用，如1204 或12000 
int main(int argc, char *argv[])
{
  char array[50];
  int index = 0;//index记录数据位数 
  char std;
  printf("input the number:\n");

  while(std != '\n')
  {//录入数据，存储进入数组中 
          std = getchar();
          array[index] = std;
          index++; 
  }
 
  for(int i = 0;i < index-1;i++)
  {
          char tmp = array[i];
          cout<<num[atoi(&tmp)];//输出当前位置数字
          cout<<digit[index - i -2];//输出当前数字所在位 
  }
    system("PAUSE");
    return EXIT_SUCCESS;
}
 

#6

变量定义好象有问题：assert语句之后又定义变量，可是gcc通过了……

还有一点没有处理，就是每组的十位数：
    如果个位数不是0，并且百位数是0，不应该输出“一”；
    最高组的最高位为十位，并且十位数是1时，不应该输出“一”。

这样修改后才符合一般习惯。

    修改时改make_group_str,是否最高组可以用output0判断。

#7

#include <stdio.h>
#include <string.h>
char hznum[100];
char hzunit[15][3]={"","十","百","千","万","十","百","千","亿","十","百","千","万","十","百"};
char hzdigit[10][3]={"零","一","二","三","四","五","六","七","八","九"};
char numstr[20];
char *ReadNumByHZ(double v) {
    char *p,*d;
    int u,i;

    sprintf(numstr,"%.15lg",v);
    printf("%s\n",numstr);
    if ('-'==numstr[0]) {
        sprintf(hznum,"不支持读负数");
        return hznum;
    }
    p=strchr(numstr,'e');
    if (NULL!=p) {
        sprintf(hznum,"不支持读太大或太小的数");
        return hznum;
    }
    d=NULL;
    p=strchr(numstr,'.');
    if (NULL!=p) {
        p[0]=0;
        d=p+1;
    }
    u=strlen(numstr);
    hznum[0]=0;
    for (i=0;i<u;i++) {
        if ('0'==numstr[i] && 0!=((u-1-i)%4)) {
            sprintf(hznum,"%s%s",hznum,hzdigit[numstr[i]-'0']);
        } else {
            sprintf(hznum,"%s%s%s",hznum,hzdigit[numstr[i]-'0'],hzunit[u-1-i]);
        }
    }
    printf("%s\n",hznum);
    u=strlen(hznum);
    for (i=0;i<u;i+=2) {
        if (0==strncmp(hznum+i,"零零",4)) {//多个连续的“零”改成一个“零”
            memmove(hznum+i,hznum+i+2,u-i-2+1);
            i-=2;
            u-=2;
        }
    }
    printf("%s\n",hznum);
    if (0==strcmp(hznum+u-2,"零")) {//末尾“零”去掉
        hznum[u-2]=0;
        u-=2;
    }
    printf("%s\n",hznum);
    for (i=0;i<u;i+=2) {
        if (0==strncmp(hznum+i,"零万",4) || 0==strncmp(hznum+i,"零亿",4)) {//“万”“亿”前是“零”去掉
            memmove(hznum+i,hznum+i+2,u-i-2+1);
            u-=2;
        }
    }
    printf("%s\n",hznum);
    if (NULL!=d) {
        sprintf(hznum,"%s点",hznum);
        i=0;
        while (1) {
            if (0==d[i]) break;
            sprintf(hznum,"%s%s",hznum,hzdigit[d[i]-'0']);
            i++;
        }
    }
    printf("%s\n",hznum);
    return hznum;
}
void main() {
    printf("\n%s\n",ReadNumByHZ(130040600090.012));
}
//130040600090.012
//一千三百零零亿四千零六十零万零零九十零
//一千三百零亿四千零六十零万零九十零
//一千三百零亿四千零六十零万零九十
//一千三百亿四千零六十万零九十
//一千三百亿四千零六十万零九十点零一二
//
//一千三百亿四千零六十万零九十点零一二

#8

#include <afx.h>
#include <stdio.h>
CString ChineseCapitalMoney(double Num) {
    CString szChMoney,szNum;
    int iLen, iNum, iAddZero=0;
    TCHAR* hzUnit[18]={_T("分"),_T("角"),_T("元"),_T("拾"),_T("佰"),_T("仟"),_T("万"),_T("拾"),_T("佰"),_T("仟"),_T("亿"),_T("拾"),_T("佰"),_T("仟"),_T("万"),_T("拾"),_T("佰"),_T("仟")};
    TCHAR* hzNum[10]={_T("零"),_T("壹"),_T("贰"),_T("叁"),_T("肆"),_T("伍"),_T("陆"),_T("柒"),_T("捌"),_T("玖")};
    if (-0.01<Num && Num<0.01) return _T("零元整");
    szNum.Format(_T("%18.0f"), Num*100); // 最小到分
    szNum.TrimLeft();
    iLen=szNum.GetLength();
    if(iLen>15 || iLen==0 || Num<0) return _T(""); // 数据错误返回

    for(int i=0;i<iLen;i++) {
        iNum=_ttoi((LPCTSTR)szNum.Mid(i,1));
        if (iNum==0) {
            iAddZero++;
        } else {
            if (iAddZero>0) szChMoney+=_T("零");
            szChMoney+=hzNum[iNum];
            iAddZero=0;
        }
        if (iNum!=0 || iLen-i==3 || iLen-i==11 || ((iLen-i+1)%8==0 && iAddZero<4)) szChMoney+=hzUnit[iLen-i-1];
    }
    if (szNum.Right(2)==_T("00")) szChMoney+=_T("整"); // 没有角和分
    return szChMoney;
}
void main() {
    double d;
    CString s;

    d=-1.0            ;printf("%16.2f %s\n",d,ChineseCapitalMoney(d));
    d=0.0             ;printf("%16.2f %s\n",d,ChineseCapitalMoney(d));
    d=1234501234567.89;printf("%16.2f %s\n",d,ChineseCapitalMoney(d));
    d=1000000000000.01;printf("%16.2f %s\n",d,ChineseCapitalMoney(d));
    d=1000000000001.00;printf("%16.2f %s\n",d,ChineseCapitalMoney(d));
    d= 130040600090.01;printf("%16.2f %s\n",d,ChineseCapitalMoney(d));
}
//           -1.00
//            0.00 零元整
//1234501234567.89 壹万贰仟叁佰肆拾伍亿零壹佰贰拾叁万肆仟伍佰陆拾柒元捌角玖分
//1000000000000.01 壹万亿元零壹分
//1000000000001.00 壹万亿零壹元整
// 130040600090.01 壹仟叁佰亿零肆仟零陆拾万零玖拾元零壹分