最近看到一个很有意思的对象处理相关问题。
 在php中使用clone可以克隆复制一个对象，克隆的对象是和被克隆的对象相等的，但不是全等的。clone对象的定义是在对对象的属性进行一个浅复制，所有的引用属性仍然是指向原来变量的引用。
 
<?php
class myTestClass{
	public $name = "name";
	public function __construct(){
	    $this->name = $name;
	}
	public function getNmae(){
			return $this->name;
	}
}
$myClass   = new myTestClass();
$myCass1 = clone $myClass;
// $myClass == $myClass1
// $myClass !== $myClass1

?>
 
这个clone的对象和源对象不是全等的。
 php引用的定义是两个不同的变量指向相同的内容，一个对象变量不是保存对象的所有值，而是只保存一个标识符来访问真正对象内容，当这个对象变量赋值给另一个变量，这两个变量保存和记录同一个指向对象内容的标识符，这个标识符指向同一个对象的真正内容。
 
<?php
class myTestClass{
	public $name = "name";
	public function __construct(){
	    $this->name = $name;
	}
	public function getNmae(){
			return $this->name;
	}
}
$myClass    = new myTestClass();
$myC;ass1  =  &$myClass;
$myClass2  = $myClass;
// $myClass === $myClass1
// $myClass === $myClass2; 

?>

 
 
 
  
 1. 何时调用复制构造函数
 　　复制构造函数用于将一个对象复制到新创建的对象中。也就是说，它用于初始化过程中，而不是常规的赋值过程中。类的复制构造函数原型通常如下：
 　　class_name(const class_name&);
 　　它接受一个指向类对象的常量引用作为参数。例如，String类的复制构造函数的原型如下：
 　　String(const String&);
 　　新建一个对象并将其初始化为同类现有对象时，复制构造函数都将被调用。这在很多情况下都可能发生，最常见的情况是将新对象显示地初始化为现有的对象。例如，假设motto是一个String对象，则下面4种声明都将调用复制构造函数：
 　　String ditto(motto);
 　　String metoo = motto;
 　　String also = String(motto);
 　　String *pString = new String(motto);
 　　其中中间的2种声明可能会使用复制构造函数直接创建metto和also，也可能会使用复制构造函数生成一个临时对象，然后将临时对象的内容赋给 metoo和also，这取决于具体的实现。最后一种声明使用motto初始化一个匿名对象，并将新对象的地址赋给pString指针。
 2. 何时调用赋值构造函数
 　　赋值构造函数是通过重载赋值操作符实现的，这种操作符的原型如下：
 　　Class_name& Class_name::operator=(const Class_name&);
 　　它接受并返回一个指向类对象的引用。例如，String 类的赋值操作符的原型如下：
 　　String& String::operator=(const String&);
 　　将已有的对象赋给另一个对象时，将使用重载的赋值操作符：
 　　String headline1(“test”);
 　　String knot;
 　　knot = headline1;
 　　初始化对象时，并不一定会使用赋值操作符：
 　　String metoo = knot;
 　　这里，metoo是一个新创建的对象，被初始化为knot的值，考试,大提示使用复制构造函数。不过，正如前面指出的，实现时也可能分两步来处理这条语句：使用复制构造函数创建一个临时对象，然后通过赋值将临时对象的值复制到新对象中。这就是说，初始化总是会调用复制构造函数，而使用＝操作符时也可能调用赋值操作符
 　　实例代码如下：
 　　#include <iostream>
 　　using namespace std;
 　　class Test
 　　{
 　　public:
 　　Test();
 　　~Test();
 　　Test(const Test& t);
 　　Test& operator=(const Test& t);
 　　private:
 　　int t1;
 　　};
 　　Test::Test()
 　　{
 　　cout<<”调用构造函数”<<endl;
 　　}
 　　Test::~Test()
 　　{
 　　cout<<”调用析构函数”<<endl;
 　　}
 　　Test::Test(const Test& t)
 　　{
 　　cout<<”调用复制构造函数”<<endl;
 　　}
 　　Test& Test::operator =(const Test& t)
 　　{
 　　cout<<”调用赋值构造函数”<<endl;
 　　t1 = t.t1;
 　　return *this;
 　　}
 　　void main()
 　　{
 　　Test t1;
 　　Test t2 = t1;
 　　Test t3;
 　　t3 = t1;
 　　}
 　　输出如下：
 　　调用构造函数
 　　调用复制构造函数
 　　调用构造函数
 　　调用赋值构造函数
 　　调用析构函数
 　　调用析构函数
 　　调用析构函数
 
  
 
 
  
 同样是利用现有对象的值，生成/更新另一个对象的值。区别在于：复制构造函数是去完成对未初始化的存储区的初始化，而赋值操作符则是处理一个已经存在的对象。对一个对象赋值，当它一次出现时，它将调用复制构造函数，以后每次出现，都调用赋值操作符。
 
 定义对象a，并用另一个对象b对a进行初始化时，
 若没有复制构造函数时，那么编译器会自动生成一个
 T b(1);//假设对象b已经初始化
 T a(b);//初试化阶段，调用复制构造函数
 T c = b;//虽然使用了“=”，但是初试化阶段，仍调用复制构造函数
 T c = a; //因为对象c已经定义，所以此处调用赋值操作符重载函数。如果没有编译器会自动生成一个。
 
 
 
 
                </div>

部分引用：https://blog.csdn.net/liitdar/article/details/81874541
 
对象赋值
 
如同基本类型的赋值语句一样，同一个类的对象之间也是可以进行赋值操作的，即将一个对象的值赋给另一个对象。
 
对于类对象的赋值，只会对类中的数据成员进行赋值，而不对成员函数赋值。
 
给对象赋值和调用拷贝构造函数初始化另一个对象行为是类似的，但是有所区别，下面会讲到（实际上调用的是拷贝构造函数）
 
拷贝构造函数和赋值
 
拷贝构造函数和赋值运算符的行为比较相似，都是将一个对象的值复制给另一个对象；但是其结果却有些不同，拷贝构造函数使用传入对象的值生成一个新的对象的实例，而***赋值运算符是将对象的值复制给一个已经存在的实例。***这种区别从两者的名字也可以很轻易的分辨出来，拷贝构造函数也是一种构造函数，那么它的功能就是创建一个新的对象实例；赋值运算符是执行某种运算，将一个对象的值复制给另一个对象（已经存在的）。
 调用的是拷贝构造函数还是赋值运算符，主要是看是否有新的对象实例产生。如果产生了新的对象实例，那调用的就是拷贝构造函数；如果没有，那就是对已有的对象赋值，调用的是赋值运算符。
 以下代码用于辨析何时使用了拷贝构造、何时使用了赋值运算符
 
复制
 
使用拷贝构造函数操作对象的方式，称为“对象的复制”。
 
int main()
{
    Person p;
    Person p1 = p;    // 1
    Person p2;
    p2 = p;           // 2
    f(p2);            // 3

    p2 = f1();        // 4

    Person p3 = f1(); // 5

    getchar();
    return 0;
}
 
1、使用对象 p创建了一个新的对象p1，毫无疑问使用的是拷贝构造函数
 2、p2这个对象已经提前声明好了，执行的仅仅只是将p的值复制给p2
 3、这个就是拷贝构造函数 调用时机 之一“对象以值传递的方式传入函数参数”
 4、这条语句拷贝构造函数和赋值运算符都调用了。函数f1以值的方式返回一个Person对象，在返回时会调用拷贝构造函数创建一个临时对象tmp作为返回值；返回后调用赋值运算符将临时对象tmp赋值给p2
 5、直接调用拷贝构造函数使用f1()返回值创建了对象p3
 
特别要说的是
 
对象进行赋值时，两个对象必须属于同一个类；
s2 = s1； 只会使得学生2和学生1的各项数据相同，但是学生还是两个独立的个体；
对象赋值是通过赋值运算函数实现的\
在对象声明之后，进行的对象赋值运算，才属于“真正的”对象赋值运算，即使用了赋值运算符“=”；而在对象初始化时，针对对象进行的赋值操作，其实是属于对象的复制。
 
//就是说  通过一个对象创建了另一个对象 调用的是拷贝构造函数（strcpy函数），执行的是复制操作
	Person p;
    Person p1 = p;    // 1
    
//对象全部创建好之后，执行的"="  才算是赋值操作
    ClassA obj1;
    ClassA obj2;
    obj2 = obj1; // 此语句为对象的赋值

 
赋值操作中内存变化
 
int main()
{
    ClassA obj1(1, "liitdar");
    ClassA obj2;
 
    return 0;
}
 
上述中，声明了对象obj1和obj2之后，系统将会为其分配相应大小的内存空间（由于obj1初始化了，所以空间中存放的是liitdar 但是obj2并没初始化，所以存的是随机值）
 注：图片来源https://blog.csdn.net/liitdar/article/details/81874541
 
 执行赋值操作后 obj2 = obj2; 会将对象中的所有位于 stack 中的域进行相应的复制操作；
 
 目前就到这个程度，望指正。

 
 本文属于上篇博文《C++区别于其他语言的知识点总结》第13小节。
 
13.对象的赋值和复制
 
对象的赋值：C++中对象可以使用”=”进行赋值，通过重载”=”号运算符实现，实际上这个过程是通过成员赋值(mewberwise copy)实现的，即将一个对象的成员一一赋值给另一对象的对应成员。注意：对象的赋值只是对其中数据成员的赋值，而不是对成员函数赋值。 
 对象1 = 对象2；//浅拷贝 浅复制
 
Box *b1 = new Box(1, 2, 3); //C++类Java对象声明 必须使用指针
Box *b2;
b1 = b2; //浅拷贝
delete b1;
delete b2;//同一块地址 删了2次

Box b1 = Box(1， 2， 3)；
Box b2；
b2 = b1;//位复制方式给b2赋值 想当于b1的内存完全copy给b1
//当这里给b2赋值时，回到时b2的p指针和b1的p指针指向同一个地方 即b1的p
//当程序运行结束时，会导致同一个内存在各自的析构函数中释放，累计释放了2次。
 
//深拷贝 深复制
 
补充：深拷贝和浅拷贝的区别： 
 https://www.zhihu.com/question/36370072
 
对象的复制：用一个已有的对象快速地多个完全相同的对象。 
 //对象赋值：两个对象都已经存在，然后用一个对象给另一个对赋值 
 //对象复制：已经有一个对象，再创建另一个对象时，用已知的对象初始化创建对象
 
对象复制的一种形式：
 
Box box2(box1);//类名 对象2(对象1);
//用对象1复制出对象2 建立对象时调用了一个特殊的构造函数——copy构造函数(copy constructor)
//the copy constructor definition 详见课本101页
Box :: Box(const Box&b) {
    height = b.height;
    width = b.width;
    length = b.length;
}
 
对象复制的另一种形式:
 
Box box2 = box1;//类名 对象1 = 对象2;
 
两者区别： 
 对象的赋值是对一个已经存在的对象赋值，因此必须先定义被赋值的对象，才能进行对象的赋值。而对象的复制则是从无到有地建立一个新对象，并使它与一个已有的对象的完全相同(包括对象的结构和成员的值)。
 
 c3 = c1.complex_add(c2);//此处存在对象的赋值和复制问题
 
//对象的复制，存在于实参到形参以及函数的返回中
 
//实现机制实例
//重载=号实现对象赋值
Person& operator= (Person &s) {
    puts("oper");
    if(this == &s)  return s;
    char *t = new char[srelen(s.p) + 1];
    strcpy(t, s.p);
    delete []p;
    p = t;
    return this*;
}
//Copy构造函数实现对象复制
Person (const Person& s) {
    puts("cp cntr");
    p  = new char[strlen(s.p) + 1];
    strcpy(p, s.p);
}