• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>
            數據加載中……

            Cstring、String、double、int之間轉換,精度控制

            用的是boost1.46.1版本,這個版本的lexical庫比1.36有改進,

            float為:9 double:17;string類型的為:118  windows平臺

            函數集提供了精度的控制。可以按照要求輸出小數點后固定格式的字符串。比如:125.000  (精確到小數點后3位)。

            #include <boost/lexical_cast.hpp>
            #include 
            <cmath>
            #include 
            <iomanip>

            using boost::lexical_cast;

            bool Double2MFCStr(double dValue, CString &str, int precision)
            {
                std::
            string stdStr = Double2String(dValue,precision);
                str 
            = StdStr2MFCStr(stdStr);

                
            return true;
            }


            bool MFCStr2Double(CString str, double &dValue)
            {    
                std::
            string stdStr = MFCStr2StdStr(str);
                
            try
                
            {
                    dValue 
            = lexical_cast<double>(stdStr);
                }

                
            catch (boost::bad_lexical_cast& e)
                
            {
                    (e);
                    
            return false;
                }
                
                
            return true;
            }



            double String2Double(const char* ch)
            {
                
            double nInt = 0.0;
                
            double nD = 0.0;
                
            while(*ch&&*ch!='.')
                
            {
                    nInt 
            = nInt*10 + *ch - '0';
                    ch
            ++;
                }


                
            if (*ch=='.')
                
            {
                    ch
            ++;
                    nD
            =0.1;
                    
            while(*ch)
                    
            {
                        nInt 
            += (*ch - '0')*nD;
                        nD 
            = nD/10;
                        ch
            ++;
                    }

                }


                
            return nInt;
            }



            bool String2Double(const std::string &stdstr, double &dValue)
            {    
                
            try
                
            {
                    dValue 
            = lexical_cast<double>(stdstr);
                }

                
            catch (boost::bad_lexical_cast& e)
                
            {
                    (e);
                    
            return false;
                }
                
                
            return true;
            }


            bool String2Int(const std::string &stdstr, int &nValue)
            {
                
            try
                
            {
                    nValue 
            = (int)lexical_cast<double>(stdstr);
                }

                
            catch (boost::bad_lexical_cast& e)
                
            {
                    (e);
                    
            return false;
                }
                
                
            return true;
            }


            std::
            string Int2String(int nValue)
            {
                std::
            string str = "";
                
            try
                
            {
                    str 
            = lexical_cast<std::string>(nValue);
                }

                
            catch (boost::bad_lexical_cast& e)
                
            {
                    (e);
                }

                
            return str;
            }



            std::
            string Int2String(int nValue,int precision)
            {
                std::
            string str = "";

                std::stringstream ss;
                ss 
            << std::fixed << std::setprecision(precision);
                ss 
            << nValue;

                
            int  result;
                ss 
            >> result;

                
            try
                
            {
                    str 
            = lexical_cast<std::string>(result);
                }

                
            catch (boost::bad_lexical_cast& e)
                
            {
                    (e);
                }

                
            return str;
            }




            double Round(double dValue,int precision)
            {

                
            double minus = dValue>0?1.0:-1.0;
                
            for (int i=0;i!=precision+1;i++)
                
            {
                    minus 
            = minus/10.0;
                }

                
            if ((fabs(dValue)-fabs(minus))<1e-6)
                
            {
                    
            return 0;
                }

                
            double m = minus*5;
                std::stringstream ss;
                ss 
            << std::fixed << std::setprecision(precision);
                ss 
            << dValue ;

                
            double result;
                ss 
            >> result;
                
            return result + m;
            }


            std::
            string Double2String(double dValue,int precision)
            {
                std::
            string str = "";
                
            try
                
            {
                    str 
            = lexical_cast<std::string>(Round(dValue,precision));
                    size_t n 
            = str.find('.');
                    
            if ( n == std::string::npos)
                    
            {
                        str.append(
            ".");
                        
            for (int i=0;i!=precision;i++)
                        
            {
                            str.append(
            "0");
                        }

                    }
            else
                    
            {
                        
            if ((str.size()> n+precision)) //后面至少還有decplaces位嗎? 
                        {
                            str[n
            +precision+1]='\0';//覆蓋第一個多余的數 
                            str.swap(std::string(str.c_str()));//刪除nul之后的多余字符
                        }
            else
                        
            {
                            size_t size
            =str.size();
                            
            for (int i=0;i!=(n+precision+1-size);i++)
                            
            {
                                str.append(
            "0");
                            }

                        }

                    }

                }

                
            catch (boost::bad_lexical_cast& e)
                
            {
                    (e);
                }

                
            return str;
            }




            std::
            string MFCStr2StdStr(CString str)
            {
                std::
            string strStl;
            #ifdef _UNICODE
                CStringA stra(str.GetBuffer(
            0));
                str.ReleaseBuffer();
                strStl 
            = stra.GetBuffer(0);
                stra.ReleaseBuffer();
            #else
                strStl
            =str.GetBuffer(0); 
            #endif
                
            return strStl;
            }


            CString StdStr2MFCStr(
            const std::string &stdstr)
            {
                
            //CString strMFC;
                
            //strMFC = stdstr.c_str(); 
                
            //return strMFC;
                if (stdstr=="")
                
            {
                    
            return CString();
                }
            else
                
            {
                    
            return CString(stdstr.c_str());
                }

            }


            void Split(const CString& source,const CString& division,CStringArray& dest)
            {
                
            //CStringArray dest;
                dest.RemoveAll();
                
            int pos = 0;
                
            int pre_pos = 0;
                
            while-1 != pos )
                
            {
                    pre_pos 
            = pos;
                    pos 
            = source.Find(division,(pos+1));
                    dest.Add(source.Mid(pre_pos,(pos
            -pre_pos)));
                }

            }


            char* MFCString2Char(CString str)
            {
                
            char * szText = new char[str.GetLength()+1] ;
                WideCharToMultiByte(CP_ACP,
            0,str.GetBuffer(),-1,szText,MAX_PATH,NULL,NULL);
                
            return szText;
            }


            errno_t Char2WChar_t(
            const char *pChar,wchar_t* pWchar)
            {
                
            if (pWchar==NULL)
                
            {
                    
            return EINVAL;
                }

                
            // Convert to a wchar_t*
                size_t origsize = strlen(pChar) + 1;
                
            const size_t newsize = 1024;
                size_t convertedChars 
            = 0;
                pWchar 
            = new wchar_t[newsize];
                
            return mbstowcs_s(&convertedChars, pWchar, origsize, pChar, _TRUNCATE);
            }



            void GetFileTitleFromFileName(CString fullPath,
                                                            CString
            & dirName,
                                                            CString
            & fileNameWithOutExt,
                                                            CString
            & ExtendName) //獲取文件名和擴展名
            {
                
            int Where;
                Where
            =fullPath.ReverseFind('\\');
                
            if(Where==-1)
                
            {
                    Where
            =fullPath.ReverseFind('/');
                }

                dirName 
            = fullPath.Left(Where);
                fileNameWithOutExt 
            = fullPath.Right(fullPath.GetLength()-1-Where);

                
            int Which=fileNameWithOutExt.ReverseFind('.');
                ExtendName
            =fileNameWithOutExt.Right(fileNameWithOutExt.GetLength()-Which-1);
                
            if (Which!=-1)
                
            {
                    fileNameWithOutExt
            =fileNameWithOutExt.Left(Which);
                }
                
            }


            /*
               string to time_t
               時間格式  2009-3-24
               
            */

            int StringToTime(const std::string &strDateStr,time_t &timeData)
            {
                
            char *pBeginPos = (char*) strDateStr.c_str();
                
            char *pPos = strstr(pBeginPos,"-");
                
            if(pPos == NULL)
                
            {     
                    
            return -1;
                }

                
            int iYear = atoi(pBeginPos);
                
            int iMonth = atoi(pPos + 1);
                pPos 
            = strstr(pPos + 1,"-");
                
            if(pPos == NULL)
                
            {       
                    
            return -1;
                }

                
            int iDay = atoi(pPos + 1);
                
            struct tm sourcedate;
                memset((
            void*)&sourcedate,0,sizeof(sourcedate));
                sourcedate.tm_mday 
            = iDay;
                sourcedate.tm_mon 
            = iMonth - 1;
                sourcedate.tm_year 
            = iYear - 1900;
                timeData 
            = mktime(&sourcedate);
                
            return 0;
            }

            /*
               time_t to string
               
            */

            int TimeToString(std::string &strDateStr,const time_t &timeData)
            {
                
            char chTmp[15];
                memset(chTmp,
            0,sizeof(chTmp));
                
            struct tm *p=NULL;
                localtime_s(p,
            &timeData);
                p
            ->tm_year = p->tm_year + 1900;
                p
            ->tm_mon = p->tm_mon + 1;
                sprintf_s(chTmp,
            sizeof(chTmp),"04d-%02d-%02d",
                        p
            ->tm_year, p->tm_mon, p->tm_mday);
                strDateStr 
            = chTmp;
                
            return 0;
            }


            posted on 2011-03-31 12:10 Stone xin 閱讀(4540) 評論(0)  編輯 收藏 引用 所屬分類: STL&&BOOST

            久久精品无码av| 久久ww精品w免费人成| 久久亚洲国产午夜精品理论片| 久久精品国产精品亚洲精品| 国产女人aaa级久久久级| 久久久中文字幕| 久久精品免费一区二区三区| 精品久久久久久无码专区不卡| 亚洲香蕉网久久综合影视 | 国产精品久久久久久一区二区三区| 综合久久一区二区三区| 色综合久久中文字幕综合网| 久久人妻少妇嫩草AV蜜桃| 久久亚洲国产成人影院网站| 久久男人AV资源网站| 久久婷婷色综合一区二区| 亚洲国产精品综合久久网络| 久久av免费天堂小草播放| 久久精品三级视频| 伊人久久大香线蕉综合5g| 久久精品极品盛宴观看| 精品久久久无码21p发布 | 久久99精品久久久大学生| 久久精品人人做人人爽电影| 色偷偷久久一区二区三区| 久久久久亚洲Av无码专| 久久99国产精一区二区三区| 久久这里只精品国产99热| 久久e热在这里只有国产中文精品99| 国产精品xxxx国产喷水亚洲国产精品无码久久一区 | 国产成人精品白浆久久69| 91精品国产91久久久久福利| 国产免费久久久久久无码| 狠狠色丁香久久婷婷综合蜜芽五月 | 中文字幕乱码久久午夜| 久久精品国产精品亚洲精品| 日本精品一区二区久久久| 久久久久亚洲AV无码永不| 国产精品久久久天天影视香蕉 | 69国产成人综合久久精品| 青青热久久国产久精品|