C++19——拷贝构造

void func(Currency p){
    cout<<"X="<<p.dollars();
}
Currency bucks(100,0);
func(bucks);

Currency p=bucks;//初始化
p=bucks;//赋值

在C++中可以用=和()初始化对象。

Person baby_a("Fred");
Person baby_b=baby_a;
Person baby_c(baby_a);

#include<iostream>
uaing namespace std;
static int objectCount=0;

class HowMany{
public:
    HowMany(){objectCount++;print("HowMany()");}
    HowMany(int i){objectCount++;print("HowMany(int)");}
    HowMany(const HowMany& o){objectCount++;print("HowMany(HM)");}//拷贝构造，传参数，在传的过程中不会进行拷贝构造
    HowMany(HowMany o){objectCount++;print("HowMany(HM)");}//错误，传的时候进行拷贝构造，递归了，没有结束的条件

    void print(const string& msg=""){
    if(msg.size()!=0) cout<<msg<<":";
    cout<<"objectCount"<<objectCount<<endl;
	}
    ~HowMany(){
        objectCount--;
        print("~HowMany()");
    }
};
HowMany f(HowMany x){
    cout<<"begin of f"<<endl;
    x.print("x argument inside f()");
    cout<<"end of f"<<endl;
    return x;
}
int main(){
    HowMany h;
    h.print("after construction of h");
    HowMany h2=h;
    //HowMany h2=f(h);
    h.print("after call to f()");
}

T::T(const T&);//拷贝构造，成员对成员的拷贝，而非字节对字节的拷贝

#include<iostream>
#include<cstring>
using namespace std;
class Person{
public:
    Person(const char*s);
    ~Person();
    void print();
    char* name;
    
}
Person::Person(const char*s){
    name=new char[::strlen(s)]+1;
    ::strcpy(name,s);
}
Person::~Person(){
    delete [] name;
}

int main(){
    Person p1("John");
    Person p2(p1);
    printf("p1.name=%p\n",p1.name);
    printf("p2.name=%p\n",p2.name);//p1 p2的name相同
    //存在错误，p1和p2指向同一段字符串的内存，p1和p2都要析构，意味着那段字符串被析构了两次，错误
}

#include<iostream>
#include<cstring>
using namespace std;
class Person{
public:
    Person(const char*s);
    Person(const Person& w);//Person的拷贝构造
    ~Person();
    void print();
    char* name;
    
}
Person::Person(const char*s){
    name=new char[::strlen(s)]+1;
    ::strcpy(name,s);
}
Person::Person(const Person& w){
    name=new char[::strlen(w.name)+1];
    ::strcpy(name,w.name);
}
Person::~Person(){
    delete [] name;
}

int main(){
    Person p1("John");
    Person p2(p1);//构造了一个新的Person对象
    printf("p1.name=%p\n",p1.name);
    printf("p2.name=%p\n",p2.name);//p1 p2的name相同
    //正确
}

Person captain(){
    Person player("George");
    return player;//返回对象，此处也会发生拷贝构造
}

Person f(){
    Person ip;//默认构造
    return ip;
}
int main(){
    Person p=f();//拷贝构造
    return 0;
}

#include<iostream>
#include<cstring>
using namespace std;
class Person{
public:
    Person(const string&);
    ~Person();
    void print();
    string name;
    
}
Person::Person(const string&){
    ......
}
Person::~Person(){
    delete [] name;
}

int main(){
    Person p1("John");
    Person p2(p1);
    printf("p1.name=%p\n",p1.name);
    printf("p2.name=%p\n",p2.name);//p1 p2的name相同
    //正确，string作为系统标准类库里的类一定存在拷贝构造，因此，不写拷贝构造也可以
}

C++建议使用string，而非char*。