Question

我构造了一个名为CMyString的类，这里是：

class CMyString {
public:
    CMyString();
    CMyString(char* pData);
    CMyString(const CMyString& str);
    ~CMyString(void);

    char* getData();
    void setData(char* pData);

    CMyString& operator=(const CMyString& str);

private:
    char* m_pData;
};

    CMyString::CMyString() {
    m_pData = new char;
}

CMyString::CMyString(char* pData) {
//    m_pData = new char;
    m_pData = pData;
}

CMyString::CMyString(const CMyString& str) {
    // 为指针分配内存
//    m_pData = new char;
    // 拷贝值
    m_pData = str.m_pData;
}

CMyString::~CMyString(void) {
//    delete m_pData;
}

CMyString& CMyString::operator=(const CMyString& str) {
    if (this == &str)
        return *this;

    delete m_pData;
    m_pData = nullptr;
    m_pData = new char[strlen(str.m_pData) + 1];
    strcpy(m_pData, str.m_pData);

    return *this;
}

char* CMyString::getData() {
    return m_pData;
}

void CMyString::setData(char *pData) {
    m_pData = pData;
}

这是我的main.cpp：

#include <iostream>
#include "CMyString.h"

using std::cout;
using std::endl;

int main() {
    char* pData = "What are you worrying about?";
    std::cout << pData << std::endl;

    cout << strlen(pData) << endl;
    char* test = new char[30];
    cout << sizeof(test) << endl;
    char* test2 = new char;
    test2 = "23";
    cout << test2 << endl;

    strcpy(test, pData);

    cout << endl << test << endl << endl;

    CMyString str(pData);
    std::cout << str.getData() << std::endl;

    CMyString str2, str3;
    str3 = str2 = str;

    std::cout << str3.getData() << endl;

    char* pData2 = "Data has been changed.";
    str3.setData(pData2);

    cout << str.getData() << endl;
    cout << str2.getData() << endl;
    cout << str3.getData() << endl;

    return 0;
}

然后我对

感到困惑

char* pData = new char;
char* pData2 = new char[30];

我在班级实施中是对的吗？我怎么能告诉两个不同的指针？我是否正确编写构造函数和反构造函数以及operator =？如果没有，怎么写呢？

Answer 1

char* pData = new char;  -> Allocates one piece / slot of memory
char* pData2 = new char[30]; -> Allocates 30 continuous pieces / slots of memory

第一个使用delete pData，第二个使用delete [] pData

除此之外，您使用的是char *pData = "STRING"，我不建议您使用它，因为您正在设置指向STRING的指针，而不是将其复制到某个位置。

说到operator=它看起来不错，因为我可以看到你是否传递了正确的数据..

修改看到其他评论说复制构造函数，我没有看到。

复制构造函数它构造/创建一个与构造函数相同的实例，所以如果你在构造函数和类中动态分配内存，那么你也应该在复制构造函数中这样做..

// Ofcourse #include<cstring> class CMyString { public: CMyString(); CMyString(char* pData); CMyString(const CMyString& str); ~CMyString(void); char* getData(); void setData(char* pData); CMyString& operator=(const CMyString& str); private: char* m_pData; }; CMyString::CMyString() { m_pData = nullptr; // so it doesn't hang } CMyString::CMyString(char* pData) { m_pData = new char[strlen(pData) + 1]; // allocates slots of memory with length of the string pData strcpy(m_pData, pData) } CMyString::CMyString(const CMyString& str) { m_pData = new char[strlen(str.m_pData) + 1]; strcpy(m_pData, str.m_pData); // Here you are constructing an instance so you should allocate memory for the dynamic string } CMyString::~CMyString(void) { delete [] m_pData; // Since we allocated few slots } CMyString& CMyString::operator=(const CMyString& str) { if (this == &str) return *this; delete [] m_pData; // Few slots of memory should be released // m_pData = nullptr; No need for this since you are allocating after m_pData = new char[strlen(str.m_pData) + 1]; strcpy(m_pData, str.m_pData); return *this; } char* CMyString::getData() { return m_pData; } void CMyString::setData(char *pData) { // m_pData = pData; Illegal don't get the address of a string make a copy of it (Don't point to a string you want a copy) // If it isn't set. If it is, you will need to delete it m_pData = new char[strlen(pData) + 1]; strcpy(m_pData, pData); }

如果需要编辑或添加任何内容，可能会有一些拼写错误，所以打击我..

注意： test =“字符串”是非法的，如果是您的意图（strcpy），则始终复制内容。如果人们离开，请查看其他评论，因为我仅限于当前的知识（仍然是新手）。但是，我会尽力帮助..

重要事项：在分配时尝试了解其背后的概念以及您想要做什么以及您做了什么。不要忘记删除/删除[] :) 祝你好运!!

Answer 2

嗯，你有很多错误。不在operator=。在那里，你只有一个毫无意义的m_pData = nullptr;。

new char分配一个char，new char[30]分配一个包含30个字符的数组。指针是相同的，你必须知道它是哪两个。每个新的必须通过删除来平衡，每个新的[]通过删除[]来平衡。所以最好不要混淆两者。使用new char[1]。

其余代码的一些注释：

1）m_pData = str.m_pData;复制数组的地址，所以现在2个类使用相同的数组，旧的数组永远不会被释放。

2）需要在析构函数中注释掉删除以防止内存泄漏，但应该删除[]。但是1使这不可能。

3）test2 = "23";使用不兼容的指针类型。 C字符串是const，你的编译器应该警告过你。

4）test2 = "23";复制数组的加法覆盖旧值。旧数组是内存泄漏。

5）CMyString str(pData);会将pData的地址复制到您的班级中。 2中的delete []稍后会尝试释放它，但它从未被new []分配。构造函数和setData应该像在operator =。

中那样复制字符串

6）看看std :: move，std :: uniq_ptr，std :: shared_ptr。

char * = new char和char * = new char [N]

2 个答案: