【C++学习】(04)String类 | 带指针成员类

#include 
#include 
using namespace std;
class String
{
private:
    char* m_data;//字符串首指针  句柄
public:
    String(const char* cstr);//string s1("hello!")
    String(const String& str);//string s3(s1) 拷贝构造函数
    ~String();//析构函数
    char* get_str() const {return m_data;}
    char* change_str(const char* str)
    {
        strcpy(m_data, str);
        return m_data;
    }
};
 
String::String(const char* cstr = 0)
{
    if(cstr)
    {
        m_data = new char[strlen(cstr) + 1];
        strcpy(m_data,cstr);
    }
    else
    {
        m_data = new char[1];
        *m_data = '\0';
    }   
}
 
inline String::String(const String& str)
{
    m_data = new char[strlen(str.m_data)+1];
    strcpy(m_data,str.m_data);
}
 
String::~String()
{
    delete[] m_data;
}
 
ostream& operator<<(ostream &os,const String &str)
{
    os << str.get_str() ;
    return os;
}
main()
{
    String A("hello");
    String B = A;
    cout << "A:" << A << endl;
    cout << "B:" << B << endl;
    A.change_str("word");
    cout << "A:" << A << endl;
    cout << "B:" << B << endl;
    return 0;
}

结果：

A:hello
B:hello
A:word
B:hello

侯捷老师讲的是，B = A这种简单的赋值方法，得到的结果是A和B的内容完全相同，也就是说A和B里面的指针也是相同的，也就说A和B指向同一块内存，改变A的值，B也会变化，然而我得到的结果不是这样的。
string是一个指针成员的类，必须具有拷贝构造函数，拷贝赋值函数，拷贝赋值函数容易造成内存泄漏。
接着上一次的博客继续探讨：

#include 
#include 
using namespace std;
class String
{
private:
    char* m_data;
    char* n_data;
public:
    String(const char* m_cstr,const char* n_cstr);
    String(const String& str);
    ~String();
    char* get_m_str() const {return m_data;}
    char* get_n_str() const {return n_data;}
    char* change_m_str(const char* str)
    {
        strcpy(m_data, str);
        return m_data;
    }
    char* change_n_str(const char* str)
    {
        strcpy(n_data, str);
        return n_data;
    }
};
 
String::String(const char* m_cstr = 0,const char* n_cstr = 0)
{
    if(m_cstr&&n_cstr)
    {
        m_data = new char[strlen(m_cstr) + 1];
        strcpy(m_data,m_cstr);
        n_data = new char[strlen(n_cstr) + 1];
        strcpy(n_data,n_cstr);
    }
    else
    {
        m_data = new char[1];
        *m_data = '\0';
        n_data = new char[1];
        *n_data = '\0';
    }   
}
 
inline String::String(const String& str)
{
    m_data = new char[strlen(str.m_data)+1];
    strcpy(m_data,str.m_data);
    n_data = new char[strlen(str.n_data)+1];
    strcpy(n_data,str.n_data);
}
 
String::~String()
{
    delete[] m_data;
    delete[] n_data;
}
 
ostream& operator<<(ostream &os,const String &str)
{
    os << str.get_m_str() << "-----" << str.get_n_str();
    return os;
}
main()
{
    String A("hello","word");
    String B = A;
    cout << "A:" << A << endl;
    cout << "B:" << B << endl;
    cout<<"A.m_data:"<<static_cast<void*>(A.get_m_str())<<"A.n_data:"<<static_cast<void*>(A.get_n_str()) << endl;
    cout<<"B.m_data:"<<static_cast<void*>(B.get_m_str())<<"B.n_data:"<<static_cast<void*>(B.get_n_str()) << endl;
 
    return 0;
}

结果：

A:hello-----word
B:hello-----word
A.m_data:0x614c20A.n_data:0x614c40
B.m_data:0x614c60B.n_data:0x614c80

为了查看在拷贝的时候类中的指针是否会改变，我特意在类中设置了两个指针。

经测试：

String B = A;
这种在初始化的时候直接赋值，A和B中的指针指向的地址是不同的。

接下来继续测试：

#include 
#include 
using namespace std;
class String
{
private:
    char* m_data;
    char* n_data;
public:
    String(const char* m_cstr,const char* n_cstr);
    String(const String& str);
    ~String();
    char* get_m_str() const {return m_data;}
    char* get_n_str() const {return n_data;}
    char* change_m_str(const char* str)
    {
        strcpy(m_data, str);
        return m_data;
    }
    char* change_n_str(const char* str)
    {
        strcpy(n_data, str);
        return n_data;
    }
};
 
String::String(const char* m_cstr = 0,const char* n_cstr = 0)
{
    if(m_cstr&&n_cstr)
    {
        m_data = new char[strlen(m_cstr) + 1];
        strcpy(m_data,m_cstr);
        n_data = new char[strlen(n_cstr) + 1];
        strcpy(n_data,n_cstr);
    }
    else
    {
        m_data = new char[1];
        *m_data = '\0';
        n_data = new char[1];
        *n_data = '\0';
    }   
}
 
inline String::String(const String& str)
{
    m_data = new char[strlen(str.m_data)+1];
    strcpy(m_data,str.m_data);
    n_data = new char[strlen(str.n_data)+1];
    strcpy(n_data,str.n_data);
}
 
String::~String()
{
    delete[] m_data;
    delete[] n_data;
}
 
ostream& operator<<(ostream &os,const String &str)
{
    os << str.get_m_str() << "-----" << str.get_n_str();
    return os;
}
main()
{
    String A("hello","word");
    String B;
    B = A;
    A.change_n_str("C++");
    cout << "A:" << A << endl;
    cout << "B:" << B << endl;
    cout<<"A.m_data:"<<static_cast<void*>(A.get_m_str())<<"A.n_data:"<<static_cast<void*>(A.get_n_str()) << endl;
    cout<<"B.m_data:"<<static_cast<void*>(B.get_m_str())<<"B.n_data:"<<static_cast<void*>(B.get_n_str()) << endl;
 
    return 0;
}

结果是：

A:hello-----C++
B:hello-----C++
A.m_data:0x614c20A.n_data:0x614c40
B.m_data:0x614c20B.n_data:0x614c40

可见，

String A(“hello”,“word”);
String B;
B = A;
这种初始化之后，再进行拷贝的方法，A和B中的指针指向的地址是相同的，而且改变任意一个指针指向的内容，另一个都会改变。显然这不是我们希望得到的结果，我们接下来对“=”这种符号进行重载。

#include 
#include 
using namespace std;
class String
{
private:
    char* m_data;
    char* n_data;
public:
    String(const char* m_cstr,const char* n_cstr);
    String(const String& str);
    ~String();
    char* get_m_str() const {return m_data;}
    char* get_n_str() const {return n_data;}
    String& operator=(const String& str);
    char* change_m_str(const char* str)
    {
        strcpy(m_data, str);
        return m_data;
    }
    char* change_n_str(const char* str)
    {
        strcpy(n_data, str);
        return n_data;
    }
};
 
String::String(const char* m_cstr = 0,const char* n_cstr = 0)
{
    if(m_cstr&&n_cstr)
    {
        m_data = new char[strlen(m_cstr) + 1];
        strcpy(m_data,m_cstr);
        n_data = new char[strlen(n_cstr) + 1];
        strcpy(n_data,n_cstr);
    }
    else
    {
        m_data = new char[1];
        *m_data = '\0';
        n_data = new char[1];
        *n_data = '\0';
    }   
}
 
inline String::String(const String& str)
{
    m_data = new char[strlen(str.m_data)+1];
    strcpy(m_data,str.m_data);
    n_data = new char[strlen(str.n_data)+1];
    strcpy(n_data,str.n_data);
}
 
String::~String()
{
    delete[] m_data;
    delete[] n_data;
}
 
String& String::operator=(const String& str)
{
    if (this == &str)
    {
        return *this;
    }
    else
    {
        delete[] m_data;
        delete[] n_data;
        m_data = new char[strlen(str.m_data)+1];
        strcpy(m_data,str.m_data);
        n_data = new char[strlen(str.n_data)+1];
        strcpy(n_data,str.n_data);
        return *this;
    }
    
    
}
 
ostream& operator<<(ostream &os,const String &str)
{
    os << str.get_m_str() << "-----" << str.get_n_str();
    return os;
}
main()
{
    String A("hello","word");
    String B;
    B = A;
    A.change_n_str("C++");
    cout << "A:" << A << endl;
    cout << "B:" << B << endl;
    cout<<"A.m_data:"<<static_cast<void*>(A.get_m_str())<<"A.n_data:"<<static_cast<void*>(A.get_n_str()) << endl;
    cout<<"B.m_data:"<<static_cast<void*>(B.get_m_str())<<"B.n_data:"<<static_cast<void*>(B.get_n_str()) << endl;
 
    return 0;
}

结果是：

A:hello-----C++
B:hello-----word
A.m_data:0x614c20A.n_data:0x614c40
B.m_data:0x614c80B.n_data:0x614c60

可见用这种符号重载的方式，成功的解决了我们的问题。

总结：

如果我们的类中带有指针，要想进行拷贝类的操作最好是重载“=”赋值号。