c++构造函数、复制构造函数、赋值构造函数、析构函数

class CMyString
{
    public:
        CMyString( const char *pData );
        //CMyString(const CMyString &str);
        CMyString(const CMyString *str);
        ~CMyString(void);
        CMyString & operator = (const CMyString &str);
        
    private:    
            char *m_pData;
};


CMyString::CMyString(const char *pData )
{
        cout << "自定义构造函数" << endl;
        if(pData == NULL)
        {
                m_pData = new char[1];
                *m_pData = '\0';
        }        
        else
        {
            int len = strlen(pData);
            m_pData = new char[len + 1];
            memcpy(m_pData,pData,sizeof(char)*(len+1));
        }
}

/*
CMyString::CMyString(const CMyString &str)
{
        cout << "自定义拷贝构造函数" << endl;
        int len = strlen(str.m_pData);
        m_pData = new char[len +1];
        memcpy(m_pData,str.m_pData,sizeof(char)*(len+1));
}
*/

CMyString::CMyString(const CMyString *str)
{

        cout << "自定义拷贝构造函数 2" << endl;
        int len = strlen(str->m_pData);
        m_pData = new char[len +1];
        memcpy(m_pData,str->m_pData,sizeof(char)*(len+1));
}


/*
CMyString & CMyString::operator = (const CMyString &str)
{
    cout << "自定义赋值函数" << endl;
    if(this == &str)
        return *this;
    
    delete [] m_pData;
    m_pData = NULL;
    
    m_pData = new char[strlen(str.m_pData)+1];
    strcpy(m_pData,str.m_pData);

    return *this;
}
*/
            
CMyString & CMyString::operator = (const CMyString &str)
{
    cout << "自定义赋值函数2" << endl;
    if(this != &str)
    {
        CMyString strTemp(str);
        char *pTemp = strTemp.m_pData;
        strTemp.m_pData = m_pData;
        m_pData = pTemp;
    }
    return *this;
}

CMyString::~CMyString(void)
{
    cout << "自定义析构函数" << endl;
    delete [] m_pData;            
}

void test()
{
        cout << "a(\"abc\")" << endl;
    CMyString a("abc");

    //cout << "b(\"cde\")" << endl;
    //CMyString b("cde");
    
    //cout << " d = a" << endl;
    //CMyString d = a;

    //cout << "c(b)" << endl;
    //CMyString *b = &a;
    CMyString c(&a);

    //cout << "c = a" << endl;
    //c = a;

    cout << endl;
}

总结

拷贝构造函数是对象被创建时调用，赋值函数只能被已经存在了的对象调用

注意浅复制与深复制区别

浅复制，同时指向同一块内存，谁来负责释放那块空间，很有可能导致同一块内存被释放两次

深复制，各自有各自申请的内存，各自负责释放各自申请的内存

当你不需要“重新指向”时，引用一般优先于指针被选用。

这通常意味着引用用于类的公有接口时更有用。

引用出现的典型场合是对象的表面，而指针用于对象内部。

class B
{
public:
B()
{
cout<<"default constructor"<<endl;
}
~B()
{
cout<<"destructed"<<endl;
}
B(int i):data(i)    
{
cout<<"constructed by parameter "<< data <<endl;
}
B(B const &b)
{
cout<<"constructed by copye\n";
}
B & operator = (B const &b)
{
cout<<"constructed by =\n";
}
private:
int data;
};


B Play( B b) 
//B Play( B &b) 
{
return b ;
}


void test()
{
//B t2;
//B t1 = Play(t2); 

B t1 = Play(5); 
B t2;
t2 = t1;

}


int main()      
{
test();
return 0;
}                                    
  

请设计一个string类，实现字符串的基本操作（构造函数，复制构造函数，求子串，=重载，+= 重载，匹配）

#include <iostream> 
#include <cstring> 


using namespace std; 
class String{ 
public: 
// 默认构造函数 
String(const char* str = NULL); 
// 复制构造函数 
String(const String &str);
// 析构函数 
~String();
// 字符串连接 
String operator+(const String & str); 
// 字符串连接 
String operator+=(const String & str); 
// 字符串赋值 
String & operator=(const String &str); 
// 字符串赋值 
String & operator=(const char* str); 
// 判断是否字符串相等
bool operator==(const String &str);
// 获取字符串长度 
int length(); 
// 求子字符串[start,start+n-1] 
String substr(int start, int n); 
// 重载输出 
friend ostream & operator<<(ostream &o,const String &str); 

private:
char* data; 
int size;
};


// 构造函数 
String::String(const char *str)
{ 
cout<<"string ()"<<endl;
if(str == NULL)
{
data = new char[1];
data[0] = '\0';
size = 0;
}
else
{
size = strlen(str);
data = new char[size+1]; 
strcpy(data,str);
}
}
// 复制构造函数 
String::String(const String &str)
{
cout<<"string (&)"<<endl;
size = str.size;
data = new char[size+1];
strcpy(data,str.data);
} 


// 析构函数 
String::~String()
{ 
cout<<"~string ()"<<endl;
delete[] data;
} 


// 字符串连接 
String String::operator+(const String &str)
{
cout<<"string +"<<endl;
String newStr; 
//释放原有空间 
delete[] newStr.data;
newStr.size = size + str.size;
newStr.data = new char[newStr.size+1]; 
strcpy(newStr.data,data);
strcpy(newStr.data+size,str.data);
return newStr;
} 


// 字符串连接 
String String::operator+=(const String &str)
{
cout<<"string +="<<endl;
String newStr; 
//释放原有空间 
delete[] newStr.data;
newStr.size = size + str.size;
newStr.data = new char[newStr.size+1]; 
strcpy(newStr.data,data);
strcpy(newStr.data+size,str.data);

delete data;
size = newStr.size;
data = new char[size+1];
strcpy(data,newStr.data);


delete[]newStr.data;
newStr.data = NULL;

return *this;
} 




// 字符串赋值 
String & String::operator=(const String &str)
{ 
cout<<"string = & "<<endl;
if(data == str.data)
{ 
cout<<"string = & == "<<endl;
return *this;
}


delete [] data;
size = str.size;
data = new char[size+1]; 
strcpy(data,str.data); 
return *this;
} 
// 字符串赋值 
String& String::operator=(const char* str)
{ 
cout<<"string = *"<<endl;
if(data == str)
return *this;
delete[] data;

size = strlen(str);
data = new char[size+1]; 
strcpy(data,str); 
return *this;
} 
// 判断是否字符串相等
bool String::operator==(const String &str)
{ 
cout<<"string =="<<endl;
return strcmp(data,str.data) == 0;
}


// 获取字符串长度 
int String::length()
{
return size;
} 
// 求子字符串[start,start+n-1] 
String String::substr(int start, int n)
{
cout<<"string sub"<<endl;
String newStr; 
// 释放原有内存 
delete [] newStr.data; 
// 重新申请内存 
newStr.data = new char[n+1];
for(int i = 0;i < n;++i)
{
newStr.data[i] = data[start+i];
}
newStr.data[n] = '\0';
newStr.size = n; 
return newStr;
} 
// 重载输出 
ostream & operator<<(ostream &o, const String &str)
{
cout<<"string << "<<endl;
o<<str.data;
return o;
} 


void test()
{
string a = "ab";
string b = "12";


a += b += b;
cout<<a<<endl;
}




int main()
{

//test();


String str1("hello ");
String str2("hello ");

//str2 = str1;


//cout<<str1<<endl;
//cout<<str2<<endl;

//String str2 = "world";
//String str2 = str1;
//str1 += str2;// += str2;

//cout<<str1<<endl;

String str3 = str1 + str2; 

/*
cout<<"str1->"<<str1<<" size->"<<str1.length()<<endl;
cout<<"str2->"<<str2<<" size->"<<str2.length()<<endl;
cout<<"str3->"<<str3<<" size->"<<str3.length()<<endl;


///
String str4("helloworld"); 
if(str3 == str4)
{ 
cout<<str3<<" 和 "<<str4<<" 是一样的"<<endl;
}
*/
//cout<<str3.substr(6,5)<<" size->"<<str3.substr(6,5).length()<<endl; 
//*/
return 0;
}