标准c++实现CString类和TCHAR

最新推荐文章于 2024-06-24 22:07:46 发布
最新推荐文章于 2024-06-24 22:07:46 发布
阅读量1.5k 收藏 9
点赞数 3
文章标签： CString类实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36810544/article/details/84329132
版权

程序要从windows下移植到linux下，CFlie类还好说，用到的地方比较集中，统一改成fstream就好，最坑的就数这个CString类了，分布在各个文件中，只好实现一个CString类。代码主要借鉴了网上的代码不是我重头写的，借鉴了好几个，就不列出出处了，如果你发现是你的代码请告诉我，我加上出处，谢了先！还有TCHAR也比较难搞，网上有大神给出了实现，我就直接粘过来用了，一并谢过！
CString.h

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/* 
 * File:   CString.h
 * Author: bqh
 *
 * Created on November 19, 2018, 4:05 PM
 */

#ifndef CSTRING_H
#define CSTRING_H

#include <string>
#include <assert.h>
using namespace std;

class CString {
     friend CString operator + (const char *pStr, const CString &r);
public:
 CString();          

 CString(const char *p);  

 CString(const CString &c); 

 ~CString();             
public:
	char *StrCpy(const char *pStrSrc);
        char *StrCpy(const CString &r);
        CString &operator=(const char *p);
        CString &operator=(const CString &m);
        CString operator +(const CString &r) const; //obj + obj
        CString operator +(const char *pStr) const; // obj + "String"
        CString operator += (const CString &r);  // obj += obj
        CString operator += (const char *pStr);  // obj += "String"  
        bool    operator==(CString &m);
        bool    operator>=(CString &m);
        void    Display();
        int     GetLength();
        char   *GetBuffer();
        CString Left(int len);
        CString Right(int len);
        bool    Compare(CString &strDes);
        bool    Compare(char *sDes);
        int     Find(char *strSub,int nstart=0); 
        int     ReverseFind(char *str);
        CString Replace(char *subOld,char *subNew,int start=0);
        CString Delete(int nIndwx,int nCount =1);
        CString Insert(int nIndex,char *pstr);
        CString Remove(char *pstr,int start=0);
        CString Mid(int nFirst,int nEnd);
        CString Trim(char *strDest,int nstart);
private:
        char*   m_pStr;
        int     m_len;
        char*   GetStr();
        char *Add(const char *pStr, int nBufSize) const;
	char *Copy(const char *pStrSrc);
	void Release();
};

#endif /* CSTRING_H */



/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/* 
 * File:   CString.cpp
 * Author: bqh
 * 
 * Created on November 19, 2018, 4:05 PM
 */

#include "CString.h"
#include <string.h>
#include <stdarg.h>
#include <stdio.h>

using namespace std;

CString::CString()
{
    m_pStr = NULL;
    m_len = 0;
}

CString::CString(const char *p)
{
    m_pStr = NULL;
    m_len = 0;
    if(p != NULL)
    {
        StrCpy(p);
    }
}

CString::CString(const CString &c)
{
    m_pStr = NULL;
    m_len = 0;
    if(this == &c)
    {
        return;
    }
    if(c.m_len != 0)
    {
        StrCpy(c.m_pStr);
    }
}

char *CString::Add(const char *pStr, int nBufSize) const
{
    char *pBuf = new char[nBufSize];
    char *pTemp = pBuf;

    for(int i = 0; i < m_len; i++)
    {
        pTemp[i] = m_pStr[i];
    }

    if(NULL != pStr)
    {
        int j = 0;        
        for(int i = m_len; j < nBufSize - m_len; j++, i++)
        {
            pTemp[i] = pStr[j];
        }
    }

    return pBuf;
}

CString::~CString()
{
    delete [] m_pStr;
}

char * CString::GetStr()
{
    return m_pStr;
}

int CString::GetLength()
{
    return m_len;
}

void CString::Release()     //初始化函数
{
    if(NULL != m_pStr)
    {
        delete []m_pStr;
        m_pStr = NULL;
        m_len = 0;
    }
}

char* CString::Copy(const char *pStrSrc)   //字符串复制
{
    char *pStr = m_pStr;
    for(; '\0' != (*pStr++ = *pStrSrc++); );

    return m_pStr;
    
}

//字符串复制string
char* CString::StrCpy(const char *pStrSrc)
{
    if(NULL != pStrSrc)
    {
        Release();
        
        m_len = strlen(pStrSrc);
        m_pStr = new char[m_len + 1];
        
        Copy(pStrSrc);
    }
    return m_pStr;
}

//字符串复制obj
char* CString::StrCpy(const CString &r)
{
    Release();
    
    if(0 != r.m_len)
    {
        m_len = r.m_len;
        m_pStr = new char[m_len + 1];
        
        Copy(r.m_pStr);
    }
    
    return m_pStr;
}

//赋值运算符重载
CString& CString::operator = (const CString &r)  //参数为CString对象
{
    if(this != &r) //若不是将自己给自己
    {
        if(0 != r.m_len)
        {
            StrCpy(r); //使用字符串函数重载函数
            //StrCpy(r.m_pStr);
        }
    }
    
    return *this;
}

//赋值运算符重载
CString& CString::operator = (const char *pStr)                             //参数为字符串，如果不写这个，系统自动调用默认字符串过程例子：                                            
{                                                                           //obj = "test" ->(1)临时对象 = CString("test"); (2)obj = 临时对象
    if(NULL != pStr)                                                        //如果写了这个函数，就省去了上面的临时对象过程，称作以代码空间换取效率
    {
        StrCpy(pStr);
    }
    
    return *this;
}

bool CString::operator==(CString &m)
{
    char *sSoure = m.GetStr();
    if (strcmp(m_pStr, sSoure))
        return false;
    else
        return true;

}

CString CString::operator +(const CString &r) const //obj + obj
{
    CString obj;
    if(NULL != m_pStr && NULL != r.m_pStr)
    {
        char *pBuf = Add(r.m_pStr, m_len + r.m_len+1);
        obj = pBuf;
        delete []pBuf;
    }

    return obj;
}

CString CString::operator +(const char *pStr) const                         // obj + "String"
{
    CString obj;
    if(NULL != m_pStr && NULL != pStr)
    {
        int nSize = (NULL != pStr)?strlen(pStr):0;
        char *pBuf = Add(pStr, m_len+nSize+1);
        obj = pBuf;
        delete []pBuf;
    }
    return obj;
}


CString operator + (const char *pStr, const CString &r)                   //"String" + obj
{
    if(NULL != pStr && NULL != r.m_pStr)
    {
        CString temp = pStr;
        return temp+r;
    }

    return NULL;
}


CString CString::operator += (const CString &r)                     // obj += obj
{
    *this = *this + r;

    return *this;
}

CString CString::operator += (const char *pStr)                       // obj += "String"
{
    *this = *this + pStr;

    return *this;
}

char * CString::GetBuffer()
{    
    char *p;
    p = new char[m_len];
    for (int i = 0; i < m_len; i++)
        *(p + i) = *(m_pStr + i);

    return p;
}

CString CString::Left(int len)
{
    if (len > m_len)
        len = m_len;
    char *p;
    p = new char[len];
    for (int i = 0; i < len; i++)
        *(p + i) = *(m_pStr + i);
    CString strRet(p);
    return strRet;

}

CString CString::Right(int len)
{
    int j = 0;
    if (len > m_len)
        len = m_len;
    char *p;
    p = new char[len];
    for (int i = m_len - len; i < m_len; i++)
    {
        *(p + j) = *(m_pStr + i);
        j++;
    }
    CString strRet(p);
    return strRet;
}

void CString::Display()
{
    //cout << m_pStr << endl;
}

bool CString::Compare(CString &strDes)
{
    char *p = strDes.GetStr();
    if (!strcmp(m_pStr, p))
        return true;
    else
        return false;

}

bool CString::Compare(char *sDes) //比较子串是否相等;
{
    if (!strcmp(m_pStr, sDes))
        return true;
    else
        return false;

}

int CString::Find(char *subStr, int start) //从start开始,查找子串subStr的第一个位置.
{
        assert(start < m_len);
        int i = start;
        int j = 0, pos = 0, len = strlen(subStr);

        if (len > m_len)
            return -1;
        else
        {
            while (m_pStr[i] != '\0')
            {
                if (m_pStr[i] != subStr[j])
                {
                    i++;
                    j = 0; //从下一个字符串开始比较

                }
                else //有相同的字符串
                {
                    if (j == 0)
                        pos = i;
                    i++;
                    j++;
                    if (j == len)
                        return pos;
                    if (i == m_len)
                        return -1;
                }
            }
            return -1;
        }
}

int  CString::ReverseFind(char *str)
{
    int ret = -1;
    for(int i = m_len - 1; i > -1; i--)
    {
        if(m_pStr[i] == str[0])
        {
            ret = i;
            break;
        }
    }
    return ret;
}

CString CString::Replace(char *subOld, char *subNew, int start) //返回替换后新的字符串
{
    int i;
    int pos = Find(subOld, start);
    if (pos == -1)
        return *this; //表明没有替换的,返回原来的串;
    else //表明有子串,位置为pos;
    {
        char *p1, *p2;
        if (pos >= 1)
        {
            p1 = new char[pos + 1]; //长度+1;
            for (i = 0; i < pos; i++)
                p1[i] = m_pStr[i];
            p1[i] = '\0';
        }
        else
            p1 = "";


        if ((pos + (int) strlen(subOld)) < m_len) //说明后面还有字符串
        {
            int j = 0;
            p2 = new char[m_len - pos - (int) strlen(subOld) + 1];
            for (i = pos + (int) strlen(subOld); i < m_len; i++)
            {
                *(p2 + j) = *(m_pStr + i);
                j++;
            }
            p2[j] = '\0';
        }
        else
            p2 = "";

        char *p3 = new char[(int) strlen(subNew) +(int) strlen(p2)];
        strcpy(p3, subNew);
        strcat(p3, p2);

        char *p4 = new char[(int) strlen(p3) +(int) strlen(p1)];
        strcpy(p4, p1);
        strcat(p4, p3);
        delete p1;
        delete p2;

        CString strRet(p4);
        return strRet;

    }

}

CString CString::Delete(int nIndex, int nCount)//删除从nIndex开始的nCount个字符,得到新的的字符串.
{

    assert((nIndex + nCount) <= m_len);
    char *p1, *p2;
    int i;
    if (nIndex >= 1) //表明删除前面还有字符串
    {
        p1 = new char[nIndex + 1];
        for (i = 0; i < nIndex; i++)
            *(p1 + i) = *(m_pStr + i);
        p1[i] = '\0';
    }
    else
        p1 = "";
    if ((nIndex + nCount) < m_len) //表明后面还有字符串
    {
        p2 = new char[m_len - nIndex - nCount + 1];
        int j = 0;
        for (i = nIndex + nCount; i < m_len; i++)
        {
            *(p2 + j) = *(m_pStr + i);
            j++;
        }
        p2[j] = '\0';
    }
    else
        p2 = "";
    char *tem = new char[m_len - nCount];
    strcpy(tem, p1);
    strcat(tem, p2);
    delete p1;
    delete p2;

    CString strRet(tem);
    return strRet;
}

CString CString::Insert(int nIndex, char *pstr)
{
    assert(nIndex >= 0 && nIndex < m_len);
    char *p1, *p2, *p3;
    p1 = new char[nIndex + 1];
    int i = 0;
    for (i = 0; i < nIndex; i++)
        p1[i] = m_pStr[i];
    p1[i] = '\0';

    p2 = new char[m_len - nIndex + 1];
    int j = 0;
    for (i = nIndex; i < m_len; i++)
    {
        p2[j] = m_pStr[i];
        j++;
    }
    p2[j] = '\0';

    p3 = new char[(int) strlen(p2) + (int) strlen(pstr)];
    strcpy(p3, pstr);
    strcat(p3, p2);

    char *tem = new char[m_len + (int) strlen(pstr)];
    strcpy(tem, p1);
    strcat(tem, p3);
    delete p1;
    delete p2;

    CString strRet(tem);
    return strRet;


}

CString CString::Remove(char *pstr, int start)
{
    int pos = Find(pstr, start);
    if (pos == -1)
        return *this;
    else
    {
        int len = strlen(pstr);
        char *p1, *p2;
        if (pos >= 1)
        {
            p1 = new char[pos + 1];
            int i = 0;
            for (i = 0; i < pos; i++)
                p1[i] = m_pStr[i];
            p1[i] = '\0';
        }
        else
            p1 = "";
        if (pos + len < m_len)
        {
            p2 = new char[m_len - pos - len + 1];
            int j = 0;
            for (int i = pos + len; i < m_len; i++)
            {
                p2[j] = m_pStr[i];
                j++;
            }
            p2[j] = '\0';
        }
        char *tem = new char[m_len - len];
        strcpy(tem, p1);
        strcat(tem, p2);
        CString strRet(tem);
        return strRet;
    }

}

CString CString::Mid(int nFirst, int nEnd) //得到从nFirst到nEnd的字符串
{
    assert(nFirst >= 0 && nFirst <= nEnd && nEnd < m_len);
    char *p1;
    p1 = new char[nEnd - nFirst + 2];
    int j = 0;
    for (int i = nFirst; i < nEnd; i++)
    {
        p1[j] = m_pStr[i];
        j++;
    }
    p1[j] = '\0';

    CString strRet(p1);
    return strRet;

}

使用的时候就和windows下一样了，不再列举啦。
还有个地方，就是CString有个函数Famat()这里没实现，可以在统一的头文件里加个

#include <stdarg.h>
#include <stdio.h>
string format(const char *fmt,...)
{
    #define FORMAT_MSG_BUFFER_SIZE (2048)
    char szBuffer[FORMAT_MSG_BUFFER_SIZE + 1] = { 0 };
    va_list args;
    va_start(args, fmt);
    vsnprintf(szBuffer, FORMAT_MSG_BUFFER_SIZE, fmt, args);
    va_end(args);
    std::string strRet  = szBuffer;
    return strRet;
}

然后把之前的代码比如：

CString str = "";
str.Famat(_T("%.2f"), 9.3);

改成：

string str = "";
str = format(_T("%.2f"), 9.3);
zzubqh103
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
标准C++实现字符串类CString
zhanjianshinian的专栏
11-13 1345
// String.cpp: implementation of the CString class. // ////////////////////////////////////////////////////////////////////// #include "String.h" #include #include #include #include #inclu
C++语法——字符串(CString,TCHAR*,LPCTSTR)
山上有只羊M
08-18 1279
CStringCString是一种数据类型，用于对字符串进行操作。一般来说，只有在MFC程序中才可以使用。。这里有一篇文章，介绍如何在非MFC程序中使用CString。http://www.cnblogs.com/lidabo/p/3684572.html 本文就不在进行介绍啦~~ 1、在字符串中子字符串或字符int Find(TCHAR ch) const; int Find(LPCTSTR l
CString TCHAR的互相转换
热门推荐
永远的黑山
02-28 5万+
CString－>TCHAR*的转化可以用函数GetBuff()函数原型为：LPTSTR GetBuffer( int nMinBufLength );CString str("CString"); TCHAR* szMsg = new TCHAR[100]; //其参数为CString字符串的长度 szMsg = str.GetBuffer(str.GetLength()); str.Rel
MFC---CString类（MFC常用类）
最新发布
Frank---7的博客
06-24 640
CString类作为MFC的常用类，当之无愧。可以这样说，只要是从事MFC开发，基本都会遇到使用CString类的场合。因为字符串的使用比较普遍，而CString类又提供了对字符串的便捷操作，所以它给MFC开发人员带来了高的开发效率，受到了开发者的欢迎。大家使用VS2010的话，可能会见到CStringT，实际上它是一个操作可变长度字符串的模板类。CStringT模板类有三个实例：CString、CStringA和CStringW，它们分别提供对TCHAR、char和wchar_t字符类型的字符串的操作。
CString源代码
Tommy(凌飞)的专栏
11-30 1092
CString使用的是引用技术,可以共享数据(这个大家都知道),另外空的CStirng是指向一个固定的地址的(_afxInitData). 另外CStirng是有长度限制的2147483647(无符号int 的最大值). 数据格式 struct CStringData {  long nRefs; //引用记数  int nDataLength; //字符使用长度  int nAllocLengt
CString的源代码
tmk8175的专栏
11-08 1932
#ifdef   _AFXDLL     CString::CString()     {     Init();     }     #endif         CString::CString(const   CString&   stringSrc)     {     ASSERT(stringSrc.GetData()->nRefs   !=   0);     if   (strin
Char_Cstring_TCHAR.rar_C++ CString CHAR_Char_Cstring_TCHAR_TCHAR
09-21
与C++标准库中的`std::string`类似，`CString`可以自动管理内存，但与`std::string`不同的是，`CString`在Windows环境中可以方便地与`TCHAR`和API进行交互。这意味着你可以用`CString`来处理`CHAR`和`WCHAR`类型的...
（UNICODE 与非UNICODE导致的问题）CString，TCHAR和CHAR类型的互转.docx
05-23
在C++编程中，特别是在MFC（Microsoft Foundation Classes）库中，`CString`、`TCHAR`和`CHAR`类型扮演着关键的角色，它们之间的转换是解决UNICODE和非UNICODE兼容问题的关键。 `CString`是MFC库提供的一种字符串类...
转 String,CString,TCHAR,char之间区别和联系
10-09
`std::string`是C++标准库中的字符串类，同样提供了丰富的字符串处理功能。与`CString`不同的是，`std::string`仅支持单一类型的字符集——通常是8位的`char`，即只支持MBCS。 ### 转换方法 接下来介绍几种常用的...
C++?CString用法大全
12-22
VC:CString用法大全 　列表形式的如下： 　CString的构造函数 ... 　CString( TCHAR ch， int nRepeat = 1 ); 　例：CString csStr('a'，5); 　//csStr="aaaaa" 　CString( LPCTSTR lpch， int n
C/C++的CString成员函数用法大全
12-09
CString 是 C++ 中一个常用的字符串类，它提供了许多实用的成员函数来操作字符串。在本文中，我们将详细介绍 CString 的成员函数用法大全。 构造函数 CString 中有多种构造函数，分别是： * `CString();`：默认...
CString与TCHAR数组 相互转换
05-25 1万+
转载自：http://blog.sina.com.cn/s/blog_673ccb5b0101412b.html TCHAR数组转到CString很简单：使用CString的Format就行。 TCHAR m_buf[100] = _T("Hello"); CString str; str.Format(L"%s",m_buf); CString转为
CString和string和TCHAR数组之间的转换
summeblace的博客
11-07 304
CString和string和TCHAR数组之间的转化，附有控制台上配置MFC环境的教程。
C++开发字符串CString类
weixin_42844163的博客
02-01 880
1.头文件 //String.h #pragma once #include <string.h> #include <iostream> class CString { char* m_pData; int m_nLength; public: CString(); CString(const char* p); CString(const CString&am...
CString
qq_38611124的博客
09-02 185
String.h的头文件 #define _CRT_SECURE_NO_WARNINGS #include&lt;string.h&gt; #define zjlCINT const int class CString { protected: char *Create(); char * m_data; public: //初始化 //1、不赋值 CString(); //...
c++字符串的转化 （string，char* tchar*）
11-22 8269
1.将string转化为char* string s("你好"); char *nihao=s.data(); char *nihao=s.c_str(); 2.将string转化为TCHAR[] string res("你好"); TCHAR wc[MAX_PATH];   #ifdef UNICODE   _stprintf_s(wc, MAX_PATH, _T("%S"),
CString、TCHAR*、char*转换
站在巨人的肩膀上
01-05 1415
char*、TCHAR*转换CString CString str(****) 下面详细写一下其它转换 ////////////////////////////// /* *********************************************************************** * 函数： TransCStringToTCHAR * 描述：将CString 转换
CString工作原理和常见问题分析
C++、.NET、WPF、Android
10-05 7613
关于Cstring 类版权所有©Stevencao@benq.com2003-11-6看了很多人写的程序,包括我自己写的一些代码，发现很大的一部分bug是关于MFC类中的CString的错误用法的.出现这种错误的原因主要是对CString的实现机制不是太了解。CString是对于原来标准c中字符串类型的一种的包装。因为，通过很长时间的编程，我们发现,很多程序的bug多和字符串
MFC的CString(VC6) 内存管理分析
Ghost
09-29 2450
CString 类是我们经常用到的类,所以有必要对它的内存管理模式分析一下.内存管理的演变过程如下： VC5 单纯的使用new delete方法。因为字符串操作需要频繁调整内存大小.而采用C++操作符 new 与 delete是没有与realloc相应功能的。结果就是每一次的改变内存大小都需要额外增加一次拷贝操作。而 new 与delete 在实现中在进程堆中分配。频繁地在堆上进行小内存分配与释放
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值