vc 转 delphi(金额转大写)

Question

STDMETHODIMP CDNRJetParser::GBMoneyEx(VARIANT var, long position, VARIANT* pValue)
{
    if (var.vt == VT_I2 || var.vt == VT_I4
        || var.vt == VT_R4 || var.vt == VT_R8 || var.vt == VT_CY)
    {
        _variant_t varTmp = var;
        varTmp.ChangeType(VT_R8);
        CComBSTR bstrValue;
        
        if (varTmp.dblVal >= 1000000000000)
            bstrValue = L"Undefine";
        else
        {
            TCHAR buf[50];#if _UNICODE  
            if (position > 0)
                wsprintf(buf, L"%d", (int)varTmp.dblVal);
            else if (position < 0)
            {
                wsprintf( buf, L"%d", (int)((varTmp.dblVal-(int)varTmp.dblVal+0.005)*100) );
            }
            //wsprintf(buf, L"%.2f", varTmp.dblVal);
#else
            if (position > 0)
                sprintf(buf, "%d", (int)varTmp.dblVal);
            else if (position < 0)
            {
                sprintf( buf, "%d", (int)((varTmp.dblVal-(int)varTmp.dblVal+0.005)*100) );
            }
            //sprintf(buf, "%.2f", varTmp.dblVal);
#endif
            int nSize = _tcslen(buf);
            if (nSize == 1)
            {
                bstrValue = number2Currency(buf, "");
            }
            else if (nSize >= position)
            {
                if (position < 0)
                    position = position==-1 ? 2 : 1;                CComBSTR bstrRet;
                bstrRet.Empty();
                USES_CONVERSION;
                if (nSize > 1)
                    Mid(T2W(buf), _tcslen(buf)-position+1, 1, bstrRet);
                //::MessageBox(NULL,W2T(bstrRet),"",0);        
                bstrValue = number2Currency(W2T(bstrRet), "");
                bstrRet.Empty();                
            }
            else
            {
                bstrValue = number2Currency("0", "");
            }
        }
        
        ::VariantClear(pValue);
        ::VariantCopy(pValue, &_variant_t(bstrValue));
    }
    
return S_OK;
}
// called by ChineseMoney()
// 最大数是万亿差一。
CString number2Currency(CString strMoney, CString strUnit)
{
    DN_INTER_STRING;
    //const CString strUnit = RSTR(_Module.m_hInstResource,IDS_STATIC_14);
    const CString strNumber = RSTR(_Module.m_hInstResource,IDS_STATIC_15);
    const CString strOtherUnit = strUnit;//RSTR(_Module.m_hInstResource,IDS_STATIC_16);
    
    // 将数字分整数部份与小数部份处理
    int nPos = strMoney.Find(".");
    int nLength = strMoney.GetLength();
    if (nPos < 0)
        nPos = nLength;
    
    CString strReturnValue;
    int nCount = 0;
    bool bZero = false;
    bool bNeedLevel = false; // 对段的识别，用于是否需要出现段名，如亿，万等
    
    // 对整数部份进行反向识别处理
    for (int i = nPos - 1; i >= 0; i--)
    {
        TCHAR ch = strMoney.GetAt(i);
        if (nCount % 4 == 0 && nCount > 0)
        {
            // 如果处理的数字为第四位（万），或第八位（亿）等，则要求置段
            bNeedLevel = true;
        }
        
        if (ch == _T('0'))
        {
            // 只对拾佰仟位的０进行识别，主要考虑到拾的特殊性，即如１０读壹拾，不会读壹拾零
            //if (nCount % 4 != 0)
                strReturnValue += strNumber.Left(2);
        }
        else
        {
            CString strTemp(strReturnValue);
            strReturnValue = strNumber.Mid((ch - 0x30) * 2 , 2);
            if (nCount > 0)
            {
                strReturnValue += strUnit;//.Mid(nCount * 2 , 2);
                if(nCount % 4 != 0 && bNeedLevel)
                {
                    // 这里判断是否需要读段名，如万，亿等
                    strReturnValue += strUnit;//.Mid(int(nCount / 4) * 8 , 2);
                }
                bNeedLevel = false;
            }
            if(bZero)
            {
                // 只有比当前处理的位要低中有数字才补零
                if(!strTemp.IsEmpty())
                    strReturnValue += strNumber.Left(2);
                bZero = false;
            }
            strReturnValue += strTemp;
        }
        
        nCount++;
    }
    
    // 如果整数为零，那么根据要求加上“零元”，否则就加“元”
//     if (strReturnValue.IsEmpty() /* && bNeedZeroYuan */)
//         ;//strReturnValue += RSTR(_Module.m_hInstResource,IDS_STATIC_17);
//     else
//         strReturnValue += strUnit;//.Left(2);
    
    
    //
    // 小数处理
    //
    int flag = 0; // 2 - 分位非零
    if (nPos < nLength) {
        for (int i = 0; i < nLength-nPos-1; i++)
        {
            TCHAR ch = strMoney.GetAt(nPos+i+1);
            if (ch != _T('0'))
            {
                if (i == 1)
                    flag = 2;
                strReturnValue += strNumber.Mid ((ch - 0x30) * 2 , 2);
                strReturnValue += strOtherUnit;//.Mid ((i + 1) * 2 , 2);
            }
        }
    }
    //if (flag == 0)
    //    strReturnValue += RSTR(_Module.m_hInstResource,IDS_STATIC_18);
    return strReturnValue;
}
// called by ChineseMoney()
// 最大数是万亿差一。
CString number2Currency(CString strMoney)
{
DN_INTER_STRING; const CString strUnit = RSTR(_Module.m_hInstResource,IDS_STATIC_14);
const CString strNumber = RSTR(_Module.m_hInstResource,IDS_STATIC_15);
const CString strOtherUnit = RSTR(_Module.m_hInstResource,IDS_STATIC_16);

// 将数字分整数部份与小数部份处理
int nPos = strMoney.Find(".");
int nLength = strMoney.GetLength();
if (nPos < 0)
nPos = nLength;

CString strReturnValue;
int nCount = 0;
bool bZero = false;
bool bNeedLevel = false; // 对段的识别，用于是否需要出现段名，如亿，万等

// 对整数部份进行反向识别处理
for (int i = nPos - 1; i >= 0; i--)
{
TCHAR ch = strMoney.GetAt(i);
if (nCount % 4 == 0 && nCount > 0)
{
// 如果处理的数字为第四位（万），或第八位（亿）等，则要求置段
bNeedLevel = true;
}

if (ch == _T('0'))
{
// 只对拾佰仟位的０进行识别，主要考虑到拾的特殊性，即如１０读壹拾，不会读壹拾零
if (nCount % 4 != 0)
bZero = true;
}
else
{
CString strTemp(strReturnValue);
strReturnValue = strNumber.Mid((ch - 0x30) * 2 , 2);
if (nCount > 0)
{
strReturnValue += strUnit.Mid(nCount * 2 , 2);
if(nCount % 4 != 0 && bNeedLevel)
{
// 这里判断是否需要读段名，如万，亿等
strReturnValue += strUnit.Mid(int(nCount / 4) * 8 , 2);
}
bNeedLevel = false;
}
if(bZero)
{
// 只有比当前处理的位要低中有数字才补零
if(!strTemp.IsEmpty())
strReturnValue += strNumber.Left(2);
bZero = false;
}
strReturnValue += strTemp;
}

nCount++;
}

// 如果整数为零，那么根据要求加上“零元”，否则就加“元”
if (strReturnValue.IsEmpty() /* && bNeedZeroYuan */)
strReturnValue += RSTR(_Module.m_hInstResource,IDS_STATIC_17);
else
strReturnValue += strUnit.Left(2);


//
// 小数处理
//
int flag = 0; // 2 - 分位非零
if (nPos < nLength) {
for (int i = 0; i < nLength-nPos-1; i++)
{
            if (atol(strMoney.Right(nLength-nPos-1)) == 0)
            {
                flag = 0;
                break;
            } TCHAR ch = strMoney.GetAt(nPos+i+1);
//if (ch != _T('0'))
{
if (i == 1)
flag = 2;
                if (i == 0) //角
                {
                    strReturnValue += strNumber.Mid ((ch - 0x30) * 2 , 2);
                    if (ch != _T('0'))
                        strReturnValue += strOtherUnit.Mid ((i + 1) * 2 , 2);
                }
                else if (i == 1 && ch != _T('0')) //分
                {
                    strReturnValue += strNumber.Mid ((ch - 0x30) * 2 , 2);
                    strReturnValue += strOtherUnit.Mid ((i + 1) * 2 , 2);
                }
            }
        }
    }
    if (flag == 0)
        strReturnValue += RSTR(_Module.m_hInstResource,IDS_STATIC_18);
return strReturnValue;
}

Answer 1

STDMETHODIMP CDNRJetParser::GBMoneyEx(VARIANT var, long position, VARIANT* pValue) 
{ 
    if (var.vt == VT_I2 || var.vt == VT_I4 
        || var.vt == VT_R4 || var.vt == VT_R8 || var.vt == VT_CY) 
    { 
        _variant_t varTmp = var; 
        varTmp.ChangeType(VT_R8); 
        CComBSTR bstrValue; 
        
        if (varTmp.dblVal >= 1000000000000) 
            bstrValue = L"Undefine"; 
        else 
        { 
            TCHAR buf[50]; #if _UNICODE  
            if (position > 0) 
                wsprintf(buf, L"%d", (int)varTmp.dblVal); 
            else if (position < 0) 
            { 
                wsprintf( buf, L"%d", (int)((varTmp.dblVal-(int)varTmp.dblVal+0.005)*100) ); 
            } 
            //wsprintf(buf, L"%.2f", varTmp.dblVal); 
#else 
            if (position > 0) 
                sprintf(buf, "%d", (int)varTmp.dblVal); 
            else if (position < 0) 
            { 
                sprintf( buf, "%d", (int)((varTmp.dblVal-(int)varTmp.dblVal+0.005)*100) ); 
            } 
            //sprintf(buf, "%.2f", varTmp.dblVal); 
#endif 
            int nSize = _tcslen(buf); 
            if (nSize == 1) 
            { 
                bstrValue = number2Currency(buf, ""); 
            } 
            else if (nSize >= position) 
            { 
                if (position < 0) 
                    position = position==-1 ? 2 : 1;                 CComBSTR bstrRet; 
                bstrRet.Empty(); 
                USES_CONVERSION; 
                if (nSize > 1) 
                    Mid(T2W(buf), _tcslen(buf)-position+1, 1, bstrRet); 
                //::MessageBox(NULL,W2T(bstrRet),"",0);        
                bstrValue = number2Currency(W2T(bstrRet), ""); 
                bstrRet.Empty();                
            } 
            else 
            { 
                bstrValue = number2Currency("0", ""); 
            } 
        } 
        
        ::VariantClear(pValue); 
        ::VariantCopy(pValue, &_variant_t(bstrValue)); 
    } 
    
return S_OK; 
} 
// called by ChineseMoney() 
// 最大数是万亿差一。 
CString number2Currency(CString strMoney, CString strUnit) 
{ 
    DN_INTER_STRING; 
    //const CString strUnit = RSTR(_Module.m_hInstResource,IDS_STATIC_14); 
    const CString strNumber = RSTR(_Module.m_hInstResource,IDS_STATIC_15); 
    const CString strOtherUnit = strUnit;//RSTR(_Module.m_hInstResource,IDS_STATIC_16); 
    
    // 将数字分整数部份与小数部份处理 
    int nPos = strMoney.Find("."); 
    int nLength = strMoney.GetLength(); 
    if (nPos < 0) 
        nPos = nLength; 
    
    CString strReturnValue; 
    int nCount = 0; 
    bool bZero = false; 
    bool bNeedLevel = false; // 对段的识别，用于是否需要出现段名，如亿，万等 
    
    // 对整数部份进行反向识别处理 
    for (int i = nPos - 1; i >= 0; i--) 
    { 
        TCHAR ch = strMoney.GetAt(i); 
        if (nCount % 4 == 0 && nCount > 0) 
        { 
            // 如果处理的数字为第四位（万），或第八位（亿）等，则要求置段 
            bNeedLevel = true; 
        } 
        
        if (ch == _T('0')) 
        { 
            // 只对拾佰仟位的０进行识别，主要考虑到拾的特殊性，即如１０读壹拾，不会读壹拾零 
            //if (nCount % 4 != 0) 
                strReturnValue += strNumber.Left(2); 
        } 
        else 
        { 
            CString strTemp(strReturnValue); 
            strReturnValue = strNumber.Mid((ch - 0x30) * 2 , 2); 
            if (nCount > 0) 
            { 
                strReturnValue += strUnit;//.Mid(nCount * 2 , 2); 
                if(nCount % 4 != 0 && bNeedLevel) 
                { 
                    // 这里判断是否需要读段名，如万，亿等 
                    strReturnValue += strUnit;//.Mid(int(nCount / 4) * 8 , 2); 
                } 
                bNeedLevel = false; 
            } 
            if(bZero) 
            { 
                // 只有比当前处理的位要低中有数字才补零 
                if(!strTemp.IsEmpty()) 
                    strReturnValue += strNumber.Left(2); 
                bZero = false; 
            } 
            strReturnValue += strTemp; 
        } 
        
        nCount++; 
    } 
    
    // 如果整数为零，那么根据要求加上“零元”，否则就加“元” 
//    if (strReturnValue.IsEmpty() /* && bNeedZeroYuan */) 
//        ;//strReturnValue += RSTR(_Module.m_hInstResource,IDS_STATIC_17); 
//    else 
//        strReturnValue += strUnit;//.Left(2); 
    
    
    // 
    // 小数处理 
    // 
    int flag = 0; // 2 - 分位非零 
    if (nPos < nLength) { 
        for (int i = 0; i < nLength-nPos-1; i++) 
        { 
            TCHAR ch = strMoney.GetAt(nPos+i+1); 
            if (ch != _T('0')) 
            { 
                if (i == 1) 
                    flag = 2; 
                strReturnValue += strNumber.Mid ((ch - 0x30) * 2 , 2); 
                strReturnValue += strOtherUnit;//.Mid ((i + 1) * 2 , 2); 
            } 
        } 
    } 
    //if (flag == 0) 
    //    strReturnValue += RSTR(_Module.m_hInstResource,IDS_STATIC_18); 
    return strReturnValue; 
} 
// called by ChineseMoney() 
// 最大数是万亿差一。 
CString number2Currency(CString strMoney) 
{ 
DN_INTER_STRING; const CString strUnit = RSTR(_Module.m_hInstResource,IDS_STATIC_14); 
const CString strNumber = RSTR(_Module.m_hInstResource,IDS_STATIC_15); 
const CString strOtherUnit = RSTR(_Module.m_hInstResource,IDS_STATIC_16); // 将数字分整数部份与小数部份处理 
int nPos = strMoney.Find("."); 
int nLength = strMoney.GetLength(); 
if (nPos < 0) 
nPos = nLength; CString strReturnValue; 
int nCount = 0; 
bool bZero = false; 
bool bNeedLevel = false; // 对段的识别，用于是否需要出现段名，如亿，万等 // 对整数部份进行反向识别处理 
for (int i = nPos - 1; i >= 0; i--) 
{ 
TCHAR ch = strMoney.GetAt(i); 
if (nCount % 4 == 0 && nCount > 0) 
{ 
// 如果处理的数字为第四位（万），或第八位（亿）等，则要求置段 
bNeedLevel = true; 
} if (ch == _T('0')) 
{ 
// 只对拾佰仟位的０进行识别，主要考虑到拾的特殊性，即如１０读壹拾，不会读壹拾零 
if (nCount % 4 != 0) 
bZero = true; 
} 
else 
{ 
CString strTemp(strReturnValue); 
strReturnValue = strNumber.Mid((ch - 0x30) * 2 , 2); 
if (nCount > 0) 
{ 
strReturnValue += strUnit.Mid(nCount * 2 , 2); 
if(nCount % 4 != 0 && bNeedLevel) 
{ 
// 这里判断是否需要读段名，如万，亿等 
strReturnValue += strUnit.Mid(int(nCount / 4) * 8 , 2); 
} 
bNeedLevel = false; 
} 
if(bZero) 
{ 
// 只有比当前处理的位要低中有数字才补零 
if(!strTemp.IsEmpty()) 
strReturnValue += strNumber.Left(2); 
bZero = false; 
} 
strReturnValue += strTemp; 
} nCount++; 
} // 如果整数为零，那么根据要求加上“零元”，否则就加“元” 
if (strReturnValue.IsEmpty() /* && bNeedZeroYuan */) 
strReturnValue += RSTR(_Module.m_hInstResource,IDS_STATIC_17); 
else 
strReturnValue += strUnit.Left(2); 
// 
// 小数处理 
// 
int flag = 0; // 2 - 分位非零 
if (nPos < nLength) { 
for (int i = 0; i < nLength-nPos-1; i++) 
{ 
            if (atol(strMoney.Right(nLength-nPos-1)) == 0) 
            { 
                flag = 0; 
                break; 
            } TCHAR ch = strMoney.GetAt(nPos+i+1); 
//if (ch != _T('0')) 
{ 
if (i == 1) 
flag = 2; 
                if (i == 0) //角 
                { 
                    strReturnValue += strNumber.Mid ((ch - 0x30) * 2 , 2); 
                    if (ch != _T('0')) 
                        strReturnValue += strOtherUnit.Mid ((i + 1) * 2 , 2); 
                } 
                else if (i == 1 && ch != _T('0')) //分 
                { 
                    strReturnValue += strNumber.Mid ((ch - 0x30) * 2 , 2); 
                    strReturnValue += strOtherUnit.Mid ((i + 1) * 2 , 2); 
                } 
            } 
        } 
    } 
    if (flag == 0) 
        strReturnValue += RSTR(_Module.m_hInstResource,IDS_STATIC_18); 
return strReturnValue; 
}

Answer 2

DELPHI也有相关的代码
蹭点分顺便

Answer 3

这还用费劲转呀,网上到处都是
http://hi.baidu.com/d7only/blog/item/008bb1e9d1fb403bb90e2dff.html

Answer 4

以前是用VC写的，到网上弄一个，银行说不标准，
所以想把以前VC的改成Delphi

Answer 5

function ToBigRMB(S: string): string; 
const 
  rmbNumber: array[0..10] of string=('零','壹','贰','叁','肆','伍','陆','柒','捌','玖','点'); {定义数组} 
  rmbUnit:array[0..15] of string=('厘','分','角','元','拾','佰','仟','万','拾','佰','仟','亿','拾','佰','仟','万'); 
var i,j:integer;                  {定义枚举变量} 
    t:string; 
begin 
  j:=pos('.',s); 
  if j=0 then 
      j:=3 
  else 
      j:=3-(length(s)-j); 
  for i:= length(s) downto 1 do 
  begin 
      case s[i] of 
        '.':begin t:=rmbNumber[10]+t; end; 
        else begin t:=rmbNumber[strtoint(s[i])]+rmbUnit[j]+t;inc(j);end; 
      end; 
  end; 
  t:=rmbNumber[0]+rmbUnit[j]+t; 
  Result:=t; 
end;