c++类型转换

 

该篇文章分两个部分：

1、数据类型说明

2、数据类型转换代码实现

 

一、数据类型说明：

int：c/c++中的整数型，该类型变量在32位编译器中占4个字节即32位

char：c/c++中的字符型，该类型变量在32位编译器中占1个字节即8位

wchar_t：c/c++中宽字符型，该类型变量在32位编译器中占2个字节即16位

c/c++中的指针类型：指针类型变量在32位编译器中占4个字节即32位，类似于int型，指针变量中存放的是一块内存的地址 

string、wstring：均为标准c++库中类包含在头文件<string>中，类的内部实际上是维护一个char*指针变量

CString：MFC封装的字符串类包含在头文件<afx.h>或者<afxwin.h>中，类的内部也是维护一个char*指针变量

还有一类类型名全部大写的如：TCHAR、LPSTR...这一类数据类型属于微软定义的宏，一般多用于WindowsAPI中参数类型或者返回值类型下图是一个对应表：

类型	在ANSI环境下	在UniCode环境下
WCHAR	wchar_t	wchar_t
LPSTR	char*	char*
LPCSTR	const char*	const char*
LPWSTR	wchar_t*	wchar_t*
LPCWSTR	const wchar_t*	const wchar_t*
TCHAR	char	wchar_t
LPTSTR	char*	wchar_t*
LPCTSTR	const char*	const wchar_t*

 二、实现代码

#pragma once

/************************************************************************/
/* win7 32位操作系统  vs2010旗舰版
    Win32控制台程序 项目属性中将MFC使用设为在共享DLL中使用MFC
*/
/************************************************************************/


#include<afxwin.h>  //使用CString类时要包含该头文件
#include <string>     //使用string类 wstring类时要包含该同文件

class TypeConver
{
public:
    TypeConver(void);
    ~TypeConver(void);
    
public:
    void Release();

    wchar_t* CToWC(const char* pch);                          //char*->wchar_t*
    char* WCToC(const wchar_t* pwch);                        //wchar_t*->char*
    //char*->string wchar_t*->wstring可以直接赋值 
    char* StrToC(const std::string& str );                        //string->char*
    char* WStrToC(const std::wstring& wstr);                 //wstring->char*
    wchar_t* StrToWC(const std::string& str);                 //string->wchar_t*
    wchar_t* WStrToWC(const std::wstring& wstr);         //wstring->wchar_t*
    std::wstring StrToWStr(const std::string& str);           //string->wstring
    std::string WStrToStr(const std::wstring& wstr);        //wstring->string
    
    CString CToCStr(const char* pch);                           //char*->CString
    CString StrToCStr(const std::string& str);                 //string->CString
    TCHAR* CStrToTC( CString& cstr);                            //CString->TCHAR
    
    char*  IntToC(const int& n);                                    //int->char*
    int CToInt(const char* pch);                                     //char*->int
    CString IntToCStr(const int& n);                              //int->CString
    int CStrToInt(const CString& cstr);                          //CString->int

private:
    char* m_char;
    wchar_t* m_wchar;

};

 

#include "StdAfx.h"
#include "TypeConver.h"


TypeConver::TypeConver(void):m_char(NULL),m_wchar(NULL)//初始化列表给私有成员变量赋值
{
}

TypeConver::~TypeConver(void)
{
    //在析构函数中释放分配的内存
    Release();
}

void TypeConver::Release()
{
    if(m_char){
        delete[] m_char;
        m_char=NULL;
    }
    if(m_wchar){
        delete[] m_wchar;
        m_wchar=NULL;
    }
}

wchar_t* TypeConver::CToWC(const char* pch)
{
    Release();
    //第一次调用该函数获得要转化字符串长度(不包含字符串最后的'\0'结束标志)
    int len=MultiByteToWideChar(CP_ACP,0,pch,strlen(pch),NULL,0);
    m_wchar=new wchar_t[len+1];  //动态分配内存 

    /*本来想用下面这条语句为上面分配的内存赋初值的但是出现中断 
    猜测原因：wchar_t占据2字节，与memset赋值单元不匹配
    memset(pch,'0',(len+1)*sizeof(wchar_t)); */

    
    /*有很多API都会有这种用法：
    第一次调用某个API获得一个参数，第二次调用同样的API将第一次获得的参数传进去得到最终想要的结果
    */
    //第二次调用该函数将pch所指的字符串复制到上面分配的内存空间上，该空间首地址为m_wchar的
    MultiByteToWideChar(CP_ACP,0,pch,strlen(pch),m_wchar,(len+1)*sizeof(wchar_t));
    m_wchar[len]='\0';//将m_wchar指向的字符串最后一个字符设为字符串结束标识符
    return m_wchar;
}

char* TypeConver::WCToC(const wchar_t* pwch)
{
    Release();
    int len=WideCharToMultiByte(CP_ACP,0,pwch,wcslen(pwch),NULL,0,NULL,NULL);
    m_char=new char[len+1];
    //memset():作用是在一段内存块中填充某个给定的值，它对较大的结构体或数组进行清零操作的一种最快方法。
    //字符型占据内存大小是1Byte，而memset函数也是以字节为单位进行赋值的，所以没有问题
    memset(m_char,0,(len+1)*sizeof(char));
    WideCharToMultiByte(CP_ACP,0,pwch,wcslen(pwch),m_char,(len+1)*sizeof(char),NULL,NULL);
    m_char[len]='\0';
    return m_char;
}

char* TypeConver::StrToC(const std::string& str )
{
    //return str.c_str();//报错：无法从"const char *"转换为"char *"
    /*const_cast<>()  作用：
    1、常量指针被转化成非常量的指针，并且仍然指向原来的对象；
    2、常量引用被转换成非常量的引用，并且仍然指向原来的对象；*/
    return const_cast<char*>(str.c_str());
}

char* TypeConver::WStrToC(const std::wstring& wstr)
{
    const wchar_t* pwch=wstr.c_str();
    return WCToC(pwch);
}

wchar_t* TypeConver::StrToWC(const std::string& str)
{
    const char* pch=str.c_str();
    return CToWC(pch);
}

wchar_t* TypeConver::WStrToWC(const std::wstring& wstr)
{
    return const_cast<wchar_t*>(wstr.c_str());
}

std::wstring TypeConver::StrToWStr(const std::string& str)
{
    std::wstring wstr;
    wchar_t* pwch=StrToWC(str);
    wstr.append(pwch);
    return wstr;
}

std::string TypeConver::WStrToStr(const std::wstring& wstr)
{
    std::string str;
    char* pch=WStrToC(wstr);
    str.append(pch);
    return str;
}

CString TypeConver::CToCStr(const char* pch)
{
    return CString(pch);
}

CString TypeConver::StrToCStr(const std::string& str)
{
    return CString(str.c_str());
}

TCHAR* TypeConver::CStrToTC(CString& cstr)
{
    TCHAR* pch=cstr.GetBuffer(cstr.GetLength());
    return pch;
}

char*  TypeConver::IntToC(const int& n)
{
    Release();
    /*int占4个字节，n最大值为2^31-1 是一个10位数 所以这里开辟一个包含11个字节的内存空间,
    个人想法如果有错或者更好的方法欢迎交流*/
    m_char=new char[11];
    _itoa_s(n,m_char,11,10);
    return m_char;
}

int TypeConver::CToInt(const char* pch)
{
    return atoi(pch);
}

CString TypeConver::IntToCStr(const int& n)
{
    CString cstr;
    cstr.Format(_T("%d"),n);
    return cstr;
}

int TypeConver::CStrToInt(const CString& cstr)
{
    return _ttoi(cstr);
}

 

声明：

(1)每篇文章中内容均为个人看法或见解，不能保证绝对正确，如果有错误或有更好的改进方案欢迎指出

(2)每篇文章最后都会附上该篇文章所参考的资料，如有侵权请参考资料的作者及时与我(persistzpf@163.com)联系，我会及时删除侵权内容

 

【参考资料 感谢作者】

http://www.cnblogs.com/Dageking/p/3520570.html

http://www.cnblogs.com/ziwuge/archive/2011/06/19/2084608.html