精华内容
下载资源
问答
  • 对象复制和对象赋值的区别

    千次阅读 2018-02-28 11:20:15
     复制构造函数用于将一个对象复制到新创建的对象中。也就是说,它用于初始化过程中,而不是常规的赋值过程中。类的复制构造函数原型通常如下:  class_name(const class_name&);  它接受一个指向类对象的常量引用...

    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>
    
    展开全文
  • 在php中使用clone可以克隆复制一个对象,克隆的对象被克隆的对象相等,但不是全等。clone对象的定义是在对对象的属性进行一个浅复制,所有引用属性仍然是指向原来变量引用。 <?php class myTestClass...

    最近看到一个很有意思的对象处理相关问题。
    在php中使用clone可以克隆复制一个对象,克隆的对象是和被克隆的对象相等的,但不是全等的。clone对象的定义是在对对象的属性进行一个浅复制,所有的引用属性仍然是指向原来变量的引用。

    <?php
    class myTestClass{
    	public $name = "name";
    	public function __construct(){
    	    $this->name = $name;
    	}
    	public function getNmae(){
    			return $this->name;
    	}
    }
    $myClass   = new myTestClass();
    $myC;ass1 = 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; 
    
    ?>
    
    展开全文
  • 拷贝构造函数,是一种特殊构造函数,它由编译器调用来完成一些基于同一类其他对象的构建及初始化。其唯一参数(对象的引用)是不可变(const类型)。此函数经常用在函数调用时用户定义类型值传递及返回。...
    拷贝构造函数,是一种特殊的构造函数,它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。其唯一的参数(对象的引用)是不可变的(const类型)。此函数经常用在函数调用时用户定义类型的值传递及返回。拷贝构造函数要调用基类的拷贝构造函数和成员函数。如果可以的话,它将用常量方式调用,另外,也可以用非常量方式调用。
    
    目录
    
    拷贝构造函数说明
    一、拷贝函数
    二、值的重载
    三、注意事宜
    四、拷贝构造与构造区别
    展开
    编辑本段
    拷贝构造函数说明
    
    调用拷贝构造函数的情形
      在C++中,下面三种对象需要调用拷贝构造函数:
      1) 一个对象以值传递的方式传入函数体;
      2) 一个对象以值传递的方式从函数返回;
      3) 一个对象需要通过另外一个对象进行初始化;
      如果在前两种情况不使用拷贝构造函数的时候,就会导致一个指针指向已经被删除的内存空间。对于第三种情况来说,初始化和赋值的不同含义是构造函数调用的原因。事实上,拷贝构造函数是由普通构造函数和赋值操作符共同实现的。描述拷贝构造函数和赋值运算符的异同的参考资料有很多。
      拷贝构造函数不可以改变它所引用的对象,其原因如下:当一个对象以传递值的方式传一个函数的时候,拷贝构造函数自动的被调用来生成函数中的对象。如果一个对象是被传入自己的拷贝构造函数,它的拷贝构造函数将会被调用来拷贝这个对象这样复制才可以传入它自己的拷贝构造函数,这会导致无限循环直至栈溢出(Stack Overflow)。除了当对象传入函数的时候被隐式调用以外,拷贝构造函数在对象被函数返回的时候也同样的被调用。
    隐式的拷贝构造函数
      如果在类中没有显式的声明一个拷贝构造函数,那么,编译器会自动生成一个来进行对象之间的位拷贝(Bitwise Copy)。这个隐含的拷贝构造函数简单的关联了所有的类成员。注意到这个隐式的拷贝构造函数和显式声明的拷贝构造函数的不同在于对成员的关联方式。显式声明的拷贝构造函数关联的只是被实例化的类成员的缺省构造函数,除非另外一个构造函数在类初始化或构造列表的时候被调用。
      拷贝构造函数使程序更有效率,因为它不用再构造一个对象的时候改变构造函数的参数列表。设计拷贝构造函数是一个良好的风格,即使是编译系统会自动为你生成默认拷贝构造函数。事实上,默认拷贝构造函数可以应付许多情况。
    示例
      以下讨论中将用到的例子:
      class CExample
      {
      public:
      CExample(){pBuffer=NULL; nSize=0;}
      ~CExample(){delete pBuffer;}
      void Init(int n){ pBuffer=new char[n]; nSize=n;}
      private:
      char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源
      int nSize;
      };
      这个类的主要特点是包含指向其他资源的指针。
      pBuffer指向堆中分配的一段内存空间。
    编辑本段
    一、拷贝函数
    
      int main(int argc, char* argv[])
      {
      CExample theObjone;
      theObjone.Init(40);
      //现在需要另一个对象,需要将他初始化称对象一的状态
      CExample theObjtwo=theObjone;
      ...
      }
      语句"CExample theObjtwo=theObjone;"用theObjone初始化theObjtwo。
      其完成方式是内存拷贝,复制所有成员的值。
      完成后,theObjtwo.pBuffer==theObjone.pBuffer。
      即它们将指向同样的地方,指针虽然复制了,但所指向的空间并没有复制,而是由两个对象共用了。这样不符合要求,对象之间不独立了,并为空间的删除带来隐患。所以需要采用必要的手段来避免此类情况。
      回顾一下此语句的具体过程:首先建立对象theObjtwo,并调用其构造函数,然后成员被拷贝。
      可以在构造函数中添加操作来解决指针成员的问题。
      所以C++语法中除了提供缺省形式的构造函数外,还规范了另一种特殊的构造函数:拷贝构造函数,上面的语句中,如果类中定义了拷贝构造函数,这对象建立时,调用的将是拷贝构造函数,在拷贝构造函数中,可以根据传入的变量,复制指针所指向的资源。
      拷贝构造函数的格式为:构造函数名(对象的引用)
      提供了拷贝构造函数后的CExample类定义为:
      class CExample
      {
      public:
      CExample(){pBuffer=NULL; nSize=0;}
      ~CExample(){delete pBuffer;}
      CExample(const CExample&); //拷贝构造函数
      void Init(int n){ pBuffer=new char[n]; nSize=n;}
      private:
      char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源
      int nSize;
      };
      CExample::CExample(const CExample& RightSides) //拷贝构造函数的定义
      {
      nSize=RightSides.nSize; //复制常规成员
      pBuffer=new char[nSize]; //复制指针指向的内容
      memcpy(pBuffer,RightSides.pBuffer,nSize*sizeof(char));
      }
      这样,定义新对象,并用已有对象初始化新对象时,CExample(const CExample& RightSides)将被调用,而已有对象用别名RightSides传给构造函数,以用来作复制。原则上,应该为所有包含动态分配成员的类都提供拷贝构造函数。
      下面介绍拷贝构造函数的另一种调用。当对象直接作为参数传给函数时,函数将建立对象的临时拷贝,这个拷贝过程也将调同拷贝构造函数。例如:
      BOOL testfunc(CExample obj);
      testfunc(theObjone); //对象直接作为参数。
      BOOL testfunc(CExample obj)
      {
      //针对obj的操作实际上是针对复制后的临时拷贝进行的
      }
      还有一种情况,也是与临时对象有关的
      当函数中的局部对象被被返回给函数调者时,也将建立此局部对象的一个临时拷贝,拷贝构造函数也将被调用
      CTest func()
      {
      CTest theTest;
      return theTest;
      }
    编辑本段
    二、值的重载
    
      下面的代码与上例相似
      int main(int argc, char* argv[])
      {
      CExample theObjone;
      theObjone.Init(40);
      CExample theObjthree;
      theObjthree.Init(60);
      //现在需要一个对象赋值操作,被赋值对象的原内容被清除,并用右边对象的内容填充。
      theObjthree=theObjone;
      return 0;
      }
    
      也用到了"="号,但与"一、"中的例子并不同,"一、"的例子中,"="在对象声明语句中,表示初始化。更多时候,这种初始化也可用括号表示。
      例如 CExample theObjone(theObjtwo);
      而本例子中,"="表示赋值操作。将对象theObjone的内容复制到对象theObjthree;,这其中涉及到对象theObjthree原有内容的丢弃,新内容的复制。
      但"="的缺省操作只是将成员变量的值相应复制。旧的值被自然丢弃。
      由于对象内包含指针,将造成不良后果:指针的值被丢弃了,但指针指向的内容并未释放。指针的值被复制了,但指针所指内容并未复制。
      因此,包含动态分配成员的类除提供拷贝构造函数外,还应该考虑重载"="赋值操作符号。
      类定义变为:
      class CExample
      {
      ...
      CExample(const CExample&); //拷贝构造函数
      CExample& operator = (const CExample&); //赋值符重载
      ...
      };
      //赋值操作符重载
      CExample & CExample::operator = (const CExample& RightSides)
      {
      if (this == &RightSides) // 如果自己给自己赋值则直接返回
      {
      return *this;
      }
      nSize=RightSides.nSize; //复制常规成员
      char *temp=new char[nSize]; //复制指针指向的内容
      memcpy(temp,RightSides.pBuffer,nSize*sizeof(char));
      delete []pBuffer; //删除原指针指向内容(将删除操作放在后面,避免X=X特殊情况下,内容的丢失)
      pBuffer=NULL;
      pBuffer=temp; //建立新指向
      return *this
      }
    编辑本段
    三、注意事宜
    
      拷贝构造函数和赋值函数的功能是相同的,为了不造成重复代码,拷贝构造函数实现如下:
      CExample::CExample(const CExample& RightSides)
      {
      *this=RightSides; //调用重载后的"="
      }
    编辑本段
    四、拷贝构造与构造区别
    
      class 类名
      {
      public:
      类名(形参参数)//构造函数
      类名(类名&对象名)//拷贝构造函数
      ,,,,,,,,,,,,,,,,,,,,,
      };
      拷贝构造函数的实现:
      类名::类名(类名&对象名)//拷贝构造函数的实现
      {函数体}
      不完整的例子
      拷贝构造函数:
      Class Point
      {
      Public:
      Point(int xx=0,int yy=m)(X=xx;Y=yy;)
      Point(Point& p);
      Int getX() {return X;}
      Int getY(){ return Y;}
      Private :
      Int X,Y;
      }
      Point::Point(Point& p)
      {
      X=p.X;
      Y=p.Y;
      Cout<<"拷贝构造函数调用"<<endl;
      }
    展开全文
  • 这种赋值是内容地址完全相同,ab在内容内存地址上是等价。修改任意一个列表,a或者b,两者同时改变。 True 1905039397384 1905039397384 二、 浅复制 方法1:切片返回列表元素 a = [1, 4, 5] b = [] ...

    列表的赋值

    一、对象的直接赋值

    a = [1, 4, 5]
    b = []
    b = a
    print(a == b)
    print(id(a))
    print(id(b))
    

    这种赋值是内容和地址的完全相同的,a和b在内容和内存地址上是等价的。修改任意一个列表,a或者b,两者同时改变。

    True
    1905039397384
    1905039397384
    

    二、 浅复制
    方法1:切片返回列表的元素

    a = [1, 4, 5]
    b = []
    b = a[:]
    print(a == b)
    print(id(a))
    print(id(b))
    

    这种切片赋值方式是b对a的对象引用,两者的地址不同,单内容相同,改变a或者b不会同时改变。

    True
    2327904342536
    2327934061704
    
    print(a is b)
    

    判断对象是否一致

    False
    

    方法2:使用list

    a = [1, 4, 5]
    b = []
    b = list(a)
    print(a == b)
    print(id(a))
    print(id(b))
    print(a is b)
    
    True
    1908907987464
    1908908542472
    False
    

    和切片方法效果一致

    方法三:copy函数

    import copy
    
    a = [1, 4, 5]
    b = []
    b = copy.copy(a)
    print(a == b)
    print(id(a))
    print(id(b))
    print(a is b)
    
    展开全文
  • 直接赋值和copy的区别:直接赋值:其实就是对象的引用(别名)。浅拷贝(copy):拷贝父对象,不会拷贝对象的内部的子对象。深拷贝(deepcopy): copy 模块的 deepcopy 方法,完全拷贝了父对象及其子对象。例子:dict1 = ...
  • /*  * 赋值,主要是区别对象赋值和普通赋值的区别  * 对主数据类型的赋值是非常直接的。由于主类型容纳了实际的值,而且并非指向一个对象的句柄,  * 所以在为其赋值的时候,可将来自一个...
  • 对象赋值 如同基本类型赋值语句一样,同一个类对象之间也是可以进行赋值操作,即将一个对象值赋给另...给对象赋值和调用拷贝构造函数初始化另一个对象行为是类似,但是有所区别,下面会讲到(实际上调用...
  • 复制构造器 复制-赋值操作符 区别   复制构造器(copy constructor): 定义新对象, 则调用复制构造器(constructor); 复制-赋值操作符(copy-assignment operator): 没有定义新对象, 不会调用构造器; 注意一个...
  • C++类对象的赋值复制(一)

    万次阅读 多人点赞 2018-08-20 17:17:07
    本文主要介绍C++中类对象赋值操作、复制操作,以及两者之间的区别,另外还会讲到“深拷贝”与“浅拷贝”的相关内容。 本系列内容会分为三篇文章进行讲解。 1 对象赋值 1.1 what 如同基本类型的赋值语句一样...
  • 1、直接赋值:默认浅复制传递对象的引用而已,原始列表改变,被赋值的b也会做相同改变。其实就是对象的引用(别名) 2、浅复制(copy):copy方法为浅复制,没有复制对象,所以原始数据改变,子对象会改变。 3、...
  • 1、复制构造函数是一个对象来初始化一块内存区域,这块内存就是新对象的内存区。 例如: class A ; A a; A b=a;//复制构造函数调用;或A b(a); 而赋值函数是对于一个已经被初始化的对象来进行operator=操作。 ...
  • 赋值运算符和复制构造函数都是用已存在B对象来创建另一个对象A。不同之处在于:赋值运算符处理两个已有对象,即赋值前B应该是存在;复制构造函数是生成一个全新的对象,即调用复制构造函数之前A不存在。  ...
  • 赋值运算符(注意,不是“赋值构造函数”)拷贝构造函数都是用已有的对象来创建另一个对象。不同之处在于:拷贝构造函数是生成一个全新的对象,即 A a (b);//这才是C++风格初始化 A a = b;//注意,这种风格...
  • 本文主要介绍C++中类对象的赋值操作、复制操作,以及两者之间的区别,另外还会讲到“深拷贝”与“浅拷贝...例如:obj1 obj2 是同一类 ClassA 的两个对象,那么对象赋值语句“obj2 = obj1;” 就会把对象 obj1 的数据
  • 对于Java赋值来说,会当讲两个对象用“=”连接起来时候,我们实际上操作是他句柄,换句话来说,以下方代码举例,如果采用 n1 = n2,n1n2都会指向最初n2所指向那个对象。 但是如果是采用 n1.i=n2.i 方式...
  • 一、深复制浅复制的区别 以我比较愚笨的理解,浅复制就是,仅复制对象的引用,而不新开辟内存,也就是说,会共享指针,当你改变复制后的对象时,其实是在改变原对象内存中的内容。 而深复制的意思是,会将新开辟...
  • 下面就详细比较下三者之间的区别以及它们的具体实现 1.构造函数 构造函数是一种特殊的类成员函数,是当创建一个类的对象时,它被调用来对类的数据成员进行初始化分配内存。(构造函数的命名必须类名完全相同...
  • 复制构造函数和赋值函数的区别: 有3个方面的区别: (1)复制构造是一个对象来初始化一块内存区域,这块内存就是新对象的内存区。而赋值函数是对于一个已经被初始化的对象来进行operator=操作。 (2)一般来说...
  • 赋值,就是创建了对象的一个新引用,修改其中任意一个变量都会影响到另一个。 浅拷贝:创建一个新的对象,但它包含是对原始对象中包含项引用(如果用引用方式修改其中 一个对象,另外一个也会修改改变) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 659
精华内容 263
关键字:

对象赋值和复制的区别