#include <iostream>
class hstring
{
private:
    unsigned short usmlen;   //新建的内存长度
    char* cstr;             //字符串
    unsigned short uslen;   //字符串长度
    unsigned short getlength(const char* str) ;     //得到对象的字符串长度
    void copystr(char* dest, const char* source);   //复制内存函数
public:
    hstring(const hstring& str);
    hstring(const char* _str);
    hstring& operator= (const hstring& str);
    char* getstr()
    {
        return cstr;
    }
    hstring();
};
hstring::hstring()
{
    usmlen = 0x32;  
    uslen = 0;
    cstr = new char[usmlen];
}
unsigned short hstring::getlength(const char* str) 
{
    unsigned short len{};
    for (; str[len];len++)
        return len;
}
void hstring::copystr(char* dest, const char* source)
{
    unsigned short len = getlength(source);
    if (len > usmlen)
    {
        cstr = new char[len];   //重新分配内存
        usmlen = len;
    }
    memcpy(dest, source, len);
}
hstring::hstring(const char* _str)
{
    copystr(cstr,_str);
}
hstring::hstring(const hstring& str)
{
    copystr(cstr, str.cstr);
}

hstring& hstring::operator=(const hstring& str)
{
    copystr(cstr, str.cstr);
    return *this;
}
int main()
{
    char str[]{ "1234567890aaaaa" };
    hstring hstr(str);
    hstring hstr1=hstr;
    std::cout << hstr.getstr()<<std::endl;
    std::cout <<hstr1.getstr();
    system("pause");
}

为什么我这里的代码跑起来就崩溃了呢？是哪里错了呢？清各位高手解答

经过您的提醒，我修改了一下代码，因为原来的代码太长了，把自己绕晕了，就决定简化程序，这是简化后的版本，但还是有错误，不知道错在哪里，麻烦您指点一下

#include <iostream>
class hstring
{
private:
    unsigned short usmlen{};   //新建的内存长度
    char* cstr;             //字符串
    unsigned short getlength(const char* str);     //得到对象的字符串长度
    void copystr(char* &dest, const char* source);   //复制内存函数
public:
    hstring(const char* _str);
    char* getstr()
    {
        return cstr;
    }
};
unsigned short hstring::getlength(const char* str)
{
    unsigned short len{};
    for (; str[len]; len++);
        return len;
}
void hstring::copystr(char* &dest, const char* source)
{
    unsigned short len = getlength(source);
    if (len > usmlen)
    {
       dest = new char[len];   //分配内存大小为字符串长度，如果小于50，则按照50来分配
        usmlen = len;
    }
    memcpy(dest, source, usmlen);
}
hstring::hstring(const char* _str)
{
    cstr = nullptr;   //当调用构造函数时，先将cstr赋值为0
    usmlen= 0x32 ;    //当调用构造函数时,将内存设置为50字节
    copystr(cstr, _str);
}

int main()
{
    const char* str{"1234552444"};
    hstring hstr(str);

    std::cout << hstr.getstr() << std::endl;
    system("pause");
}

这么写程序还是崩溃了，不知道什么原因,按照我的理解，当传入一个cosnt cha*字符串，即12345时，调用了hstring(const char* _str),然后里面调用了copystr(),copystr先算出字符串长度，然后分配内存，复制内存，最后得到复制后的cstr

[此贴子已经被作者于2023-4-18 11:25编辑过]

哇，厉害，我这样一改就对了

经过您的 提醒，现在程序差不多改好了，不过还有个不理解的地方

#include <iostream>
class hstring
{
private:
    unsigned short usmlen{};   //新建的内存长度
    char* cstr;             //字符串
    unsigned short getlength(const char* str);     //得到对象的字符串长度
    void copystr(char*& dest, const char* source);   //复制内存函数
public:
    hstring();
    hstring(const char* _str);
    hstring(const hstring& hstr);
    hstring& operator=(const hstring& str);
    //hstring& operator= (const char* str);
    char* getstr()
    {
        return cstr;
    }
};
hstring::hstring()
{
    cstr = nullptr;     //指针初始化
    usmlen = 0x32;      //给予usmlen一个初始值，不然进入copystr函数后，无法与len进行比较
}
unsigned short hstring::getlength(const char* str)
{
    unsigned short len{};
    for (; str[len]; len++);
    return len;
}
void hstring::copystr(char*& dest, const char* source)
{
    unsigned short len = getlength(source);
    if (len > usmlen)
    {
        dest = new char[len+1];   //重新分配内存
        usmlen = len;
    }
    dest = new char[0x32];
    memcpy(dest, source, usmlen);
}
hstring::hstring(const char* _str):hstring()
{
    copystr(cstr, _str);
}
hstring::hstring(const hstring& hstr):hstring()
{
    copystr(cstr, hstr.cstr);
}
hstring& hstring::operator=(const hstring& hstr)
{
    copystr(cstr, hstr.cstr);
    return *this;
}
//hstring& hstring::operator=(const char* str)
//{
//    cstr = nullptr;
//    usmlen = 0x32;
//    copystr(cstr, str);
//    return *this;
//}
int main()
{
    char* c_str{ "1234552444" };
    char a_str[]{ "88888" };
    hstring hstr=c_str;    //调用了hstring(const char* _str)                            
    hstring hstr1=hstr;     //调用了hstring(const hstring& hstr)
    hstr1 = hstr;           //调用了hstring::operator=(const hstring& hstr)
    hstr1 = a_str;          //调用了hstring& hstring::operator=(const char* str)
    std::cout << hstr.getstr() << std::endl;
    std::cout << hstr1.getstr() << std::endl;
    system("pause");
}

//hstring& hstring::operator=(const char* str)
//{
//    cstr = nullptr;
//    usmlen = 0x32;
//    copystr(cstr, str);
//    return *this;
//}
就是这里注释的地方，有的人说可以不写，因为会发生类型转换，大意是构建了一个临时的变量，然后调用了operator=(const hstring& hstr)这个函数，但是我不是很理解，能不能帮忙解释一下

#include <iostream>
class hstring
{
private:
    unsigned short usmlen{};   //新建的内存长度
    char* cstr;             //字符串    
    void copystr(char*& dest, const char* source);   //复制内存函数
public:
    hstring();
    hstring(const char* _str);
    unsigned short getlength(const char* str);     //得到对象的字符串长度
    char* getstr()
    {
        return cstr;
    }
};
hstring::hstring()
{
    cstr = nullptr;     //指针初始化
    usmlen = 0x32;      //给予usmlen一个初始值，不然进入copystr函数后，无法与len进行比较
}
unsigned short hstring::getlength(const char* str)
{
    unsigned short len{};
    for (; str[len]; len++);
    return len;
}
void hstring::copystr(char*& dest, const char* source)
{
    unsigned short len = getlength(source);
    if (len > usmlen)
    {
        dest = new char[len+1];   //重新分配内存
        usmlen = len;
    }
    dest = new char[0x32];
    memcpy(dest, source, usmlen);
}
hstring::hstring(const char* _str):hstring()
{
    copystr(cstr, _str);
}
hstring& hstring::operator+ (const hstring& hstr)   //重载+，使他能够连接对象，即连接对象里的字符
{
    unsigned int hstrlen = getlength(hstr.cstr);     //得到末尾要添加的对象的字符串长度
    unsigned int sumlen  = hstrlen + getlength(cstr);  //得到总长度，即原有字符串加新对象的字符串长                                                    
                                                        //度
    cstr = new char[sumlen];                         //给原有字符串新分配一个总长度的内存
    memcpy(cstr-hstrlen+1, hstr.cstr, hstrlen);//复制新字符串到原有字符串后面，复制长度为hstrlen
    return *this;
}
int main()
{
    char* c_str{ "1234552444" };
    hstring hstr=c_str;     //调用了hstring(const char* _str)                            
    hstr+"123456";
    std::cout << hstr1.getstr() << std::endl;
    system("pause");
}

请问，为什么我这里总是不能复制出正确的值呢？打印结果总是出现乱码，另外，请问，operator+里面的cstr被重新分配内存后，它原有的值应该不会变化把？只是增加了它的内存空间。

#include <iostream>
class hstring
{
private:
    unsigned short usmlen{};   //新建的内存长度
    char* cstr;             //字符串    
    void copystr(char*& dest, const char* source);   //复制内存函数
    unsigned short uslen    //字符串长度
public:
    hstring();
    hstring(const char* _str);
    unsigned short getlength(const char* str);     //得到对象的字符串长度
    hstring& operator<<(const hstring& hstr);
    char* getstr()
    {
        return cstr;
    }
};
hstring::hstring()
{
    cstr = nullptr;     //指针初始化
    usmlen = 0x32;      //给予usmlen一个初始值，不然进入copystr函数后，无法与len进行比较
}
unsigned short hstring::getlength(const char* str)
{
    unsigned short len{};
    for (; str[len]; len++);
    return len;
}
void hstring::copystr(char*& dest, const char* source)
{
    unsigned short len = getlength(source);
    if (len > usmlen)
    {
        dest = new char[len+1];   //重新分配内存
        usmlen = len;
    }
    dest = new char[0x32];
    uslen=len;
    memcpy(dest, source, usmlen);
}
hstring::hstring(const char* _str):hstring()
{
    copystr(cstr, _str);
}
hstring& hstring::operator<<(const hstring& hstr)   //重载<<
{
    unsigned short hstrlen = getlength(hstr.cstr);     //得到末尾要添加的对象的字符串长度
    unsigned int sumlen  = hstrlen + uslen;//得到总长度，即对象字符串+原有字符串长度                                                    
    if(sumlen>usmlen)
    {
        delete[] cstr;
        cstr = new char[sumlen];
        usmlen=sumlen; 
    }                                                   
    memcpy(cstr+uslen-1, hstr.cstr, hstrlen);//复制新字符串到原有字符串后面，复制长度为hstrlen
    return *this;
}
int main()
{
    char* c_str{ "1234552444" };
    hstring hstr=c_str;     //调用了hstring(const char* _str)                            
    hstr<<"123456";
    std::cout << hstr1.getstr() << std::endl;
    system("pause");
}

为什么我看别人这么写，它的左移运算也成功了，我写的程序是不是少了关键的哪一步呢

[此贴子已经被作者于2023-4-19 10:23编辑过]

haode