来点难地-自定义数据类型

xx_player

/////////////////////////////////////////////////////////////////
//重载操作符，自定义数据类型CString实行自动运算
// 类似stl的string,mfc的CString，Delphi的TString
///////////////////////////////////////////////////////////////
#include "stdafx.h"
#include <string.h>
#include <iostream>
using namespace std;
class CString {
        char*s;
public:
        ~CString() {
                if(s) {
                        delete[] s;
                        s = nullptr;
                }
        }
        char*get() { return s; }
        CString():s( nullptr) {}
        CString(char*p);
        CString(const char*p);
        CString(int i);

        CString& operator+(char*p);
        CString& operator+(const char*p);
        CString& operator+=(char*p);
        CString& operator+=(const char*p);
        CString& operator=(char*p);
        CString& operator=(const char*p);
        //CString& operator=(char c);

        CString& operator+(int i);
        CString& operator+=(int i);
        CString& operator=(int i);

        CString& operator+(CString& a);
        CString& operator+=(CString& a);
        CString& operator=(CString& a);
};

CString::CString(char*p) {
        int n = strlen(p);
        s = new char[n+1];
        strcpy_s(s,n+1, p);
}
CString::CString(const char*p) {
        int n = strlen(p);
        s = new char[n + 1];
        strcpy_s(s, n + 1, p);
}
CString::CString(int i) {
        char ss[20];
        sprintf_s(ss,20, "%d", i);
        int n = strlen(ss);
        s = new char[n+1];
        strcpy_s(s,n+1, ss);
}
CString& CString::operator+(char*p){
        if (!p) return *this;
        int n = strlen(p);
        if (!s) {
                s = new char[n + 1];
                strcpy_s(s, n + 1, p);
                return *this;
        }
        int n1 = strlen(s);
        char*pp = new char[n + n1 + 1];
        strcpy_s(pp,n+n1+1, s);
        strcat_s(pp, n + n1+1, p);
        delete[]s;
        s = pp;
        return *this;
}
CString& CString::operator+(const char*p) {
        if (!p) return *this;
        int n = strlen(p);
        if (!s) {
                s = new char[n + 1];
                strcpy_s(s, n + 1, p);
                return *this;
        }
        int n1 = strlen(s);
        char*pp = new char[n + n1 + 1];
        strcpy_s(pp, n + n1 + 1, s);
        strcat_s(pp, n + n1 + 1, p);
        delete[]s;
        s = pp;
        return *this;

}

CString& CString::operator+=(const char*p) {
       
        if (!p) return *this;
        int n = strlen(p);
        if (!s) {
                s = new char[n + 1];
                strcpy_s(s, n + 1, p);
                return *this;
        }
        int n1 = strlen(s);
        char*pp = new char[n + n1 + 1];
        strcpy_s(pp, n + n1 + 1, s);
        strcat_s(pp, n + n1 + 1, p);
        delete[]s;
        s = pp;
        return *this;
}
CString& CString::operator+=(char*p) {
        if (!p) return *this;
        int n = strlen(p);
        if (!s) {
                s = new char[n + 1];
                strcpy_s(s, n + 1, p);
                return *this;
        }
        int n1 = strlen(s);
        char*pp = new char[n + n1 + 1];
        strcpy_s(pp, n + n1 + 1, s);
        strcat_s(pp, n + n1 + 1, p);
        delete[]s;
        s = pp;
        return *this;
}
CString& CString::operator=(char*p) {
        if (!p) return *this;
        int n = strlen(p);
        if (s) delete[]s;
        s = new char[n + 1];
        strcpy_s(s, n + 1, p);
        return *this;
}

CString& CString::operator=(const char*p) {
        if (!p) return *this;
        int n = strlen(p);
        if (s) delete[]s;
        s = new char[n + 1];
        strcpy_s(s, n + 1, p);
        return *this;
}


CString& CString::operator+(int i) {
        char ss[20];
        sprintf_s(ss, 20, "%d", i);
        int n = strlen(ss);
        if (!s) {
                s = new char[n + 1];
                strcpy_s(s, n + 1, ss);
                return *this;
        }
        int n1 = strlen(s);
        char*p = new char[n + n1 + 1];
        strcpy_s(p,n+n1+1, s);
        strcat_s(p,n+n1+1, ss);
        delete[]s;
        s = p;
        return *this;
}

CString& CString::operator+=(int i) {
        //return operator+(i);
        char ss[20];
        sprintf_s(ss, 20, "%d", i);
        int n = strlen(ss);
        if (!s) {
                s = new char[n + 1];
                strcpy_s(s, n + 1, ss);
                return *this;
        }
        int n1 = strlen(s);
        char*p = new char[n + n1 + 1];
        strcpy_s(p, n + n1 + 1, s);
        strcat_s(p, n + n1 + 1, ss);
        delete[]s;
        s = p;
        return *this;
}

CString& CString::operator=(int i) {
        //return operator+(i);
        char ss[20];
        sprintf_s(ss, 20, "%d", i);
        int n = strlen(ss);
        if (s) delete[]s;
        s = new char[n + 1];
        strcpy_s(s, n + 1, ss);
        return *this;
}

CString& CString::operator+(CString& a) {
        char*p = a.get();
        if (!p) return *this;
        int n = strlen(p);
        if (n<1) return *this;
        if (!s) {
                s = new char[n + 1];
                strcpy_s(s, n + 1,p);
                return *this;
        }
        int n1 = strlen(s);
        char*pp = new char[n + n1 + 1];
        strcpy_s(pp, n + n1 + 1, s);
        strcat_s(pp, n + n1 + 1, p);
        delete[]s;
        s = pp;
        return *this;
}
CString& CString::operator+=(CString& a) {
        return operator+(a);
}
CString& CString::operator=(CString& a) {
        char*p = a.get();
        if (!p) return *this;
        int n = strlen(p);
        if (n<1) return *this;
        if (this == &a) {//s=s+...格式
                return *this;
        }
        if (s) delete[]s;
        s = new char[n + 1];
        strcpy_s(s, n + 1, p);
        return *this;
}

int main()
{
        CString s1,s2(55);
        s1 = 0;
        s1 +="1";
        s1 +=  CString(2)+2 +2;
        //s1 += "3" +3 + 3 ;
        //s1 += 4 + 4 +"4";
        s1 = s1+ "4" + 5 + 6 ;
        s1 += 7;
        s1 = s1 +  "88888"+99999;
        s2 = s2 +  11111 + "22222"+"33333"+ 44444 + 5555 + "66666";
        cout << s1.get() << endl;
        cout << s2.get() << endl;
    return 0;
}
运行结果:
0122245678888899999
5511111222223333344444555566666
请按任意键继续. . .
这是没有问题地。
问题在那两个注释.
s1 += "3" +3 + 3 ;
s1 += 4 + 4 +"4";
上面任何一行取消注释编译通过，结果都不对。两行对取消注释，运行结果
012228888845678888899999
5511111222223333344444555566666
请按任意键继续. . .
只看s1结果。是不对地。
鼠标放在上述行+=上显示为:
CString&CString::operator+=(const char*p)
+3重载
s1 += "3" +3 + 3 ;上是不对地
先入栈的是3,应该是CString&CString::operator+=(int i)
调试在该处，鼠标右键转到反汇编
   232:         s1 += "3" +3 + 3 ;
00843D39 68 3E AB 84 00       push        84AB3Eh  
00843D3E 8D 4D E8             lea         ecx,[ebp-18h]  
00843D41 E8 4A D4 FF FF       call        CString::operator+= (841190h)  
   233:         s1 += 4 + 4 +"4";
00843D46 68 44 AB 84 00       push        offset string "88888" (84AB44h)  
00843D4B 8D 4D E8             lea         ecx,[ebp-18h]  
00843D4E E8 3D D4 FF FF       call        CString::operator+= (841190h)  
233行压"4"竟压栈压的"88888"
总结，上述代码单目+,=都是正确地，+=双目只有1个操作数才正确，多于1个不对。
但是如果这样用s1 +=  CString(2)+2 +2;则是对的,
当然还可以s1 +=  CString(2)+"2" +2;
看看stl的处理
#include "stdafx.h"
#include <string>
#include <iostream>
using namespace std;
int main()
{
        string s;
        s = "5";
        //s = 3 + "5";
        s += "3"+5;
        s = s + "4" + "6";
        cout << s << endl;
    return 0;
}
运行结果
546
请按任意键继续. . .
由于有 s += "3"+5;   也是不对地，取消注释行,
//s = 3 + "5";
其结果更离奇
46
请按任意键继续. . .
看有没有人能变通深入解决这个问题。
即+=也能进行混排计算，如s+=1 +"2" +3+4 +“4”等等。

Debug

哇。。。这么一大篇东西，还真得仔细看看
我测试测试看看现象，好像有点意思

敏敏

谢谢楼主分享，标记一下，有空时看