#pragma once
#pragma once
#include <iostream>   //标准IO
#include "atlstr.h"   //使用CString类型
#include <string>     //使用string类型
#include <sstream>    //使用stringstream需要引入这个头文件 
using namespace std;  //标准库命名空间（cout、string）

/*
* 源博客页：https://www.cnblogs.com/timefiles/p/ConvertInValueCStringString.html
* 博客主页：https://www.cnblogs.com/timefiles
* 创建时间：2021/6/14
*/

namespace Convert
{
    //函数模板：将常用的数值类型转换为string类型变量（此方法具有普遍适用性） 
    template<typename T>
    string ToString(const T& t)
    {
        ostringstream oss;  //创建一个格式化输出流
        oss << t;           //把值传递入流中
        return oss.str();
    }
    string ToString(const int& val) { return to_string(val); }
    string ToString(const long& val) { return to_string(val); }
    string ToString(const long long& val) { return to_string(val); }
    string ToString(const unsigned int& val) { return to_string(val); }
    string ToString(const unsigned long& val) { return to_string(val); }
    string ToString(const unsigned long long& val) { return to_string(val); }
    string ToString(const float& val) { return to_string(val); }
    string ToString(const double& val) { return to_string(val); }
    string ToString(const long double& val) { return to_string(val); }


    //函数模板：将string类型变量转换为常用的数值类型（此方法具有普遍适用性） 
    template <class T>
    T ToValue(const string& str) {
        istringstream iss(str);
        T num;
        iss >> num;
        return num;
    }
    double             ToDouble(const string& str) { return  stod(str); }
    float              ToFloat(const string& str) { return  stof(str); }
    int                ToInt(const string& str) { return  stoi(str); }
    long               ToLong(const string& str) { return  stol(str); }
    long double        ToLongDouble(const string& str) { return  stold(str); }
    long long          ToLongLong(const string& str) { return  stoll(str); }
    unsigned long      ToULong(const string& str) { return  stoul(str); }
    unsigned long long ToULongLong(const string& str) { return  stoull(str); }

    namespace MFC
    {

        //将CString类型变量转换为string类型
        string CStringToString(CString cs) {
#ifdef _UNICODE

            //如果是unicode工程
            USES_CONVERSION;
            std::string str(W2A(cs));
            return str;
#else
            //如果是多字节工程 
            std::string str(cs.GetBuffer());
            cs.ReleaseBuffer();
            return str;

#endif // _UNICODE 
        }

        //将string类型变量转换为CString类型
        CString StringToCString(string str) {
#ifdef _UNICODE
            //如果是unicode工程
            USES_CONVERSION;
            CString ans(str.c_str());
            return ans;
#else
            //如果是多字节工程             
            CString ans;
            ans.Format("%s", str.c_str());
            return ans;
#endif // _UNICODE  
        }


        //模板函数：将CString类型变量转换为常用的数值类型（此方法具有普遍适用性）
        template <class T>
        T ToValue(const CString& cStr)
        {
            string str = CStringToString(cStr);
            return  Convert::ToValue<T>(str);
        }

        //模板函数：将常用的数值类型转换为CString类型变量（此方法具有普遍适用性）    
        template<typename T>
        static CString ToCString(const T& t)
        {
            string str = Convert::ToString<T>(t);
            return StringToCString(str);
        }


        CString ToString(const int& val) { CString str; str.Format(_T("%d"), val); return str; }
        CString ToString(const long& val) { CString str; str.Format(_T("%ld"), val); return str; }
        CString ToString(const unsigned int& val) { CString str; str.Format(_T("%ud"), val); return str; }
        CString ToString(const unsigned long& val) { CString str; str.Format(_T("%uld"), val); return str; }
        CString ToString(const float& val) { CString str; str.Format(_T("%.2f"), val); return str; }
        CString ToString(const double& val) { CString str; str.Format(_T("%.2f"), val); return str; }


        double             ToDouble(const CString& str) { return  _ttof(str); }
        float              ToFloat(const CString& str) { return  _ttof(str); }
        int                ToInt(const CString& str) { return  _ttoi(str); }
        long               ToLong(const CString& str) { return  _ttol(str); }
        long long          ToLongLong(const CString& str) { return  _ttoll(str); }

#ifdef _UNICODE
        //如果是unicode工程
        long double        ToLongDouble(const CString& str) { wchar_t* pEnd; return  _tcstold(str, &pEnd); }
        unsigned long      ToULong(const CString& str) { wchar_t* pEnd; return  _tcstoul(str, &pEnd, 10); }
        unsigned long long ToULongLong(const CString& str) { wchar_t* pEnd; return  _tcstoull(str, &pEnd, 10); }
#else
        //如果是多字节工程             
        long double        ToLongDouble(const CString& str) { char* pEnd; return  _tcstold(str, &pEnd); }
        unsigned long      ToULong(const CString& str) { char* pEnd; return  _tcstoul(str, &pEnd, 10); }
        unsigned long long ToULongLong(const CString& str) { char* pEnd; return  _tcstoull(str, &pEnd, 10); }
#endif // _UNICODE  

    }
}