C++类与对象：拷贝构造与内存管理-CSDN博客

如果类包含指针？

Copy pointer：

#ifndef PERSON_H_
#define PERSON_H_
class Person
{
public:
	Person(const char* s);//构造函数
	~Person();//析构函数
	void print();//函数原型，没有实际body，有一些什么样的函数
	//...
//private:
	char* name ;//数据成员 char* instead of string
	//...
};
#endif // !PERSON_H_
 
//person.h

#include "person.h"
#include<iostream>
#include<string.h>
using namespace std;
 
//在.cpp文件中定义在.h文件中声明的那些东西的实体
Person::Person(const char* s)
{
	name = new char[::strlen(s)+1];
	::strcpy(name,s);
}
Person::~Person()
{
	//delete[] name;
}
 
void Person::print()
{
	cout << "something" << endl;
}
//person.cpp

#include<stdio.h>
#include "person.h"
using namespace std;
 
int main()
{
	Person p1("Jhon");
	Person p2 = p1; //Person p2(p1);
	printf("p1.name=%p\n", p1.name);  // p1 name 的地址
	printf("p2.name=%p\n", p2.name);
	return 0;
}
//main.cpp

地址一样，报错原因：指向同一块内存，被析构了两次。

p1 和 p2 指向同一块内存，即 Copy pointer，而我们想要 Copy entire block。

character strings

in c++,a character string is
- an array of characters
- with a special terminator--"\0" or ASCII null
the string "c++" is represented,in memory,by an array of four (4,count'em) characters

C的字符串：

standard c library string functions

declared in <string>
```
size_t strlen(const char *s);
```
- s is a null-terminated string
- returns the length of s
- length does not include the terminator!
```
char *strcpy (char *dest,const char *src);
```
- copies src to dest stopping after the terminating null-character is copied
- dest should have enough memory space allocated to contain src string

Copy entire block ：

#ifndef PERSON_H_
#define PERSON_H_
class Person
{
public:
	Person(const char* s);//构造函数
	Person(const Person& w);//拷贝构造函数
	~Person();//析构函数
	void print();//函数原型，没有实际body，有一些什么样的函数
	//...
//private:
	char* name ;//数据成员 char* instead of string
	//...
};
#endif // !PERSON_H_
//person.h

#include "person.h"
#include<iostream>
#include<string.h>
using namespace std;
 
//在.cpp文件中定义在.h文件中声明的那些东西的实体
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;
}
 
void Person::print()
{
	cout << "something" << endl;
}
//person.cpp

#include<stdio.h>
#include "person.h"
using namespace std;
 
int main()
{
	Person p1("Jhon");
	Person p2 = p1;//Person p2(p1);
	printf("p1.name=%p\n", p1.name);
	printf("p2.name=%p\n", p2.name);
	return 0;
}
//main.cpp

private 是针对类而不是对象。所以访问一个同类对象的private 东西是可以的。

Person(char*) implementation

#inlcude <cstring>
ussing namespace std;

Person::Person(const char *s){
    name = new char[::strenlen(s)+1];
    ::strcpy(name,s);
}

Person::~Person(){
    delete [] name;//array delete
}

Person copy constructor

to Person declaration add copy constructor prototype
```
Person(const Person& w);//copy ctor
```

to Person .cpp add copy ctor definition

Person::Person char(const Person& w){
    name = char[::strlen(w.name)+1];
    ::strcpy(name,w.name);
}

no value return
accesses "w.name" across client boundary
the copy ctor initializes uninitialized memory

使用类的一个对象来构造另一个该类的新的对象。

when are copy constructor called?

什么时候发生拷贝构造：初始化的时候。

什么时候调用拷贝构造：

1. 调用函数时候，函数参数是一个对象本身，而不是引用或者指针的时候，隐藏调用。函数参数是一个对象本身意味着调用该函数时候，调用时候重新创建一个新的Person类的对象player，就会发生拷贝构造，因为使用某个对象初始化这个player。

during call by value 隐藏调用

void roster(Person);//declare function
Person child("Ruby");//create object
roster(child);//call function

during initialization 2.初始化时。直接调用

Person baby_a("Fred");
//these use the copy ctor
Person baby_b = baby_a;//not an assignment
Person baby_c(baby_a);//not an assignment

习惯：接受（）初始化。

during function return 3.函数返回一个对象时。

Person captain(){
    Person player("George");
    return player;
}
...
Person who("")
...

copies and overhead

compilers can "optimize out" copies when safe 把拷贝构造优化掉
programmers need to
- program for "dumb" compilers
- be ready to look for optimizations

example

Person copy_func(char *who){
    Person local(who);
    local.print();
    return local;//copy ctor called
}

Person nocopy_func(char *who){
    return Peron(who);
    //no copy needed  优化掉
}

construction vs. assignment

every object is constructed once
every object should be destroyed once
- failure to invoke delete()
- invoking delete() more than once
once an object is constructed,it can be the target of many assignment operations

Person:string name

string 类的变量不用写拷贝构造，内部实现好了。所以C++尽量用string 放弃 char*。使用 char* 只有直接访问内存，做的是二进制数据。给人读的字符串就应该使用 string。

what if the name was a string (and not a char*)

#include <string>
class Person{
public:
    Person(const string&);
    ~Person();
    void print();
    //...other accessor fxns
private:
    string name;//embedded object(composition)
    //...other data members
};

in the default ctor ,the compiler recursively calls the copy ctors for all member objects(and base classes)
default is memberwise initialization

copy ctor guidelines

in general,be explicit
- create your own copy ctor--don't rely on the default
if you don't need on declare a private copy ctor
- prevents creation of a a default copy constructor
- generates a compiler error if try to pass-by -value
- don't need a definition