#include<iostream>

#include<string>

#include<vector>

using namespace std;

class B

{

private:

    int data;

public:

    B()

    {

        cout<<"default constructor"<<endl;

    }

    ~B()

    {

        cout<<"destructed "<<endl;

    }

    B(int i):data(i)

    {

        cout<<"constructor by parameter"<<data<<endl;

    }

};

B Play(B b)

    {return b;}

int main(int agrc,char* argv[])

{

    B temp=Play(5);//why？

    return 0;

}

//mystring.h

class String

{

public:

    String (const char *str=NULL);//普通构造函数

    String(const String &other);//拷贝构造函数

    ~String(void);

    String & operator=(const String &other);

    void print();

private:

    char *m_data;//有动态申请的成员，所以需要自己定义拷贝构造函数和赋值函数

};

//mystring.cpp

#include<iostream>

#include"mystring.h"

using namespace std;

String::String(const char *str)

{

    if(str==NULL)

    {

        m_data=new char[1];

        *m_data='\0';

    }

    else

    {

        m_data=new char[strlen(str)+1];

        strcpy(m_data,str);

    }

}

String::~String(void)

{

    delete [ ] m_data;

}

String::String(const String &other)

{

    m_data=new char[strlen(other.m_data)+1];//深拷贝

    strcpy(m_data,other.m_data);

}

 String & String::operator=(const String &other)

 {

 if(this==&other)//这个if很重要。当传入的参数和当前实例（*this）是同一实例（指向同一内存），那么一旦释放自身内存，传入的参数的内存也同时被释放，因此

                 //再也找不到赋值的内容了！！！！！！！

    return *this;

 delete [] m_data;

 m_data=new char[strlen(other.m_data)+1];//新申请空间，深拷贝

 strcpy(m_data,other.m_data);

 return *this;

 }

 void String::print()

 {

     cout<<m_data<<endl;

 }

//test.cpp

#include<iostream>

#include"mystring.h"

using namespace std;

void main()

{

    String str("hello");

    str.print();

    String str1;

    str1=str;

}