#include <iostream>
using namespace std;
class Person       //Person类
{
    string name;    //两个私有属性变量name，age
    int age;
    
public:             //一个公有属性指针变量，一个无参构造函数，一个有参构造函数，一个show函数，一个拷贝构造函数
    int *p;
    Person():p(new int){}//一个无参构造函数
    Person(string name,int age):name(name),age(age),p(new int(10))//一个有参构造函数
    {cout << "Person的有参构造" << endl;}
    void show()//一个show函数
    {
        cout << "name = " << name << " age = " << age << endl;
        cout << "指针成员：" << p << "\t" << *p << endl;
    }
    ///拷贝构造函数仍然是申请空间的，所以指针成员直接指向堆区的空间
    Person(const Person &other):p(new int(*(other.p)))//一个拷贝构造函数
    {
        this->name = other.name;
        this->age = other.age;
        cout << "Person的拷贝构造函数" << endl;
    }
    ~Person()//一个析构函数
    {
        cout << p << endl;
        delete p;
    }
    //拷贝赋值函数没有初始化列表,返回自身的引用
    Person &operator=(const Person &other)//一个拷贝赋值函数
    {
        //如果传过来的就是类对象本身，不执行赋值操作
        if(&other!=this)
        {
            this->name = other.name;
            this->age = other.age;
            *(this->p) = *(other.p);    //自己实现的深拷贝赋值
            cout << "Person的拷贝赋值函数" << endl;
        }
        return *this;    //通过this指针返回自身的引用
    }
};
//fun函数的参数和返回值的位置都会调用拷贝构造函数
Person fun(Person p)
{
    return p;
}
int main()
{
    Person p1("zhangsan",12);
    p1.show();
    Person p2;
    p2 = p1;
    p2.show();
    cout << *(p2.p) << endl;
    
    return 0;
}

#include <iostream>
#include <cstring>
using namespace std;
class myString
{
    private:
        char *str;          //记录c风格的字符串
        int size;            //记录字符串的实际长度
    public:
        myString():str(new char){}//无参构造
        myString(char *str,int size):str(new char(10)),size(size){cout<<"有参构造函数"<<endl;}//有参构造
        myString(const myString &other):str(new char(*(other.str)))//一个拷贝构造函数
        {
            this->str = other.str;
            this->size = other.size;
            cout << "myString的拷贝构造函数" << endl;
        }//拷贝构造
       
        myString &operator=(const myString &other)//拷贝赋值函数
        {
            //如果传过来的就是类对象本身，不执行赋值操作
            if(&other!=this)
            {
                this->str = other.str;
                this->size = other.size;
                *(this->str) = *(other.str);    //自己实现的深拷贝赋值
                cout << "myString的拷贝赋值函数" << endl;
            }
            return *this;    //通过this指针返回自身的引用
        }
         //析构函数
        ~myString(){
            delete str;
        }
        
         void my_empty();
             
             //判空函数
        void my_size();//size函数
        void my_c_str();//c_str函数
        //at函数
        char at(int pos);
};
void myString::my_empty(){
    
}
void myString::my_size(){

}
void my_c_str(){
    
}
char myString::at(int pos){
    char s1=str[pos];
    return s1;
}