vc 转 delphi(金额转大写)

[jhldelphi]

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;
}

[jhldelphi]

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; 
}

[wintergoes]

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

[bdmh]

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

[jhldelphi]

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

[wxsan]

帮你顶一下。

[de410]

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; 

[hzw008]

ToBigRMB（），正解