程序博客网 > 怎么找淘宝代理商

拷贝构造函数

来源：互联网 发布：怎么找淘宝代理商 编辑：程序博客网 时间：2024/06/05 15:25

调用拷贝构造函数：

1. 对象以值传递的方式传入函数参数

class CExample {private: int a;public: //构造函数 CExample(int b) {   a = b;  cout<<"creat: "<<a<<endl; } //拷贝构造 CExample(const CExample& C) {  a = C.a;  cout<<"copy"<<endl; }  //析构函数 ~CExample() {  cout<< "delete: "<<a<<endl; }     void Show () {         cout<<a<<endl;     }};//全局函数，传入的是对象void g_Fun(CExample C){ cout<<"test"<<endl;}int main(){ CExample test(1); //传入对象 g_Fun(test); return 0;}

过程：

1.调用拷贝构造函数将test赋值给C;

2.析构C,析构test


2. 对象以值传递的方式从函数返回

class CExample {private: int a;public: //构造函数 CExample(int b) {   a = b; } //拷贝构造 CExample(const CExample& C) {  a = C.a;  cout<<"copy"<<endl; }     void Show ()     {         cout<<a<<endl;     }};//全局函数CExample g_Fun(){ CExample temp(0); return temp;}int main(){
CExample C= g_Fun();
 return 0;}

1. 调用拷贝构造函数，将temp赋值给C
2. 析构temp,析构C

如果仅仅是调用
g_Fun();
1. 调用拷贝构造函数，将temp赋值给一个默认匿名对象
2. 析构temp,析构这个匿名对象

三，浅拷贝和深拷贝
1. 默认拷贝构造函数
    很多时候在我们都不知道拷贝构造函数的情况下，传递对象给函数参数或者函数返回对象都能很好的进行，这是因为编译器会给我们自动产生一个拷贝构造函数，这就是“默认拷贝构造函数”，这个构造函数很简单，仅仅使用“老对象”的数据成员的值对“新对象”的数据成员一一进行赋值，

当然，以上代码不用我们编写，编译器会为我们自动生成。但是如果认为这样就可以解决对象的复制问题，那就错了，让我们来考虑以下一段代码：
class Rect{public:    Rect()      // 构造函数，计数器加1    {        count++;    }    ~Rect()     // 析构函数，计数器减1    {        count--;    }    static int getCount()       // 返回计数器的值    {        return count;    }private:    int width;    int height;    static int count;       // 一静态成员做为计数器};int Rect::count = 0;        // 初始化计数器int main(){    Rect rect1;    cout<<"The count of Rect: "<<Rect::getCount()<<endl;    Rect rect2(rect1);   // 使用rect1复制rect2，此时应该有两个对象     cout<<"The count of Rect: "<<Rect::getCount()<<endl;    return 0;}

这段代码对前面的类，加入了一个静态成员，目的是进行计数。在主函数中，首先创建对象rect1，输出此时的对象个数，然后使用rect1复制出对象rect2，再输出此时的对象个数，按照理解，此时应该有两个对象存在，但实际程序运行时，输出的都是1，反应出只有1个对象。此外，在销毁对象时，由于会调用销毁两个对象，类的析构函数会调用两次，此时的计数器将变为负数。
说白了，就是拷贝构造函数没有处理静态数据成员。
出现这些问题最根本就在于在复制对象时，计数器没有递增，我们重新编写拷贝构造函数，如下：

class Rect{public:    Rect()      // 构造函数，计数器加1    {        count++;    }    Rect(const Rect& r)   // 拷贝构造函数    {        width = r.width;        height = r.height;        count++;          // 计数器加1    }    ~Rect()     // 析构函数，计数器减1    {        count--;    }    static int getCount()   // 返回计数器的值    {        return count;    }private:    int width;    int height;    static int count;       // 一静态成员做为计数器};
2. 浅拷贝
    所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，那么浅拷贝就会出问题了，让我们考虑如下一段代码：
class Rect{public:    Rect()      // 构造函数，p指向堆中分配的一空间    {        p = new int(100);    }    ~Rect()     // 析构函数，释放动态分配的空间    {        if(p != NULL)        {            delete p;        }    }private:    int width;    int height;    int *p;     // 一指针成员};int main(){    Rect rect1;    Rect rect2(rect1);   // 复制对象    return 0;}

 在使用rect1复制rect2时，由于执行的是浅拷贝，只是将成员的值进行赋值，这时 rect1.p= rect2.p，也即这两个指针指向了堆里的同一个空间，同一个地址要释放两次，出错

3. 深拷贝
    在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间，如上面的例子就应该按照如下的方式进行处理：

class Rect{public:    Rect()      // 构造函数，p指向堆中分配的一空间    {        p = new int(100);    }    Rect(const Rect& r)    {        width = r.width;        height = r.height;        p = new int;    // 为新对象重新动态分配空间        *p = *(r.p);    }    ~Rect()     // 析构函数，释放动态分配的空间    {        if(p != NULL)        {            delete p;        }    }private:    int width;    int height;    int *p;     // 一指针成员};

这里一定要主要到拷贝构造函数和重载赋值运算符的区别：
重载运算符的函数内部要做的事情是：首先要判断是不是自我赋值
Widget & operator = (const Widget &rhs)
{
if(this == &rhs) return *this
delete p;
        p = new BitMap(*rhs.p);
return *this;
}

而拷贝构造函数不需要考虑到本身资源的释放，因为本身还不存在，还没有被构造出来！！
拷贝构造函数内部仅需要实现资源的申请即可
3. 防止默认拷贝发生
    通过对对象复制的分析，我们发现对象的复制大多在进行“值传递”时发生，这里有一个小技巧可以防止按值传递——声明一个私有拷贝构造函数。甚至不必去定义这个拷贝构造函数，这样因为拷贝构造函数是私有的，如果用户试图按值传递或函数返回该类对象，将得到一个编译错误，从而可以避免按值传递或返回对象。


四. 拷贝构造函数的几个细节
1. 拷贝构造函数里能调用private成员变量吗?
解答：这个问题是在网上见的，当时一下子有点晕。其时从名子我们就知道拷贝构造函数其时就是一个特殊的构造函数，操作的还是自己类的成员变量，所以不受private的限制。

2. 以下函数哪个是拷贝构造函数,为什么?
[c-sharp] view plaincopy
  1. X::X(const X&);      
  2. X::X(X);      
  3. X::X(X&, int a=1);      
  4. X::X(X&, int a=1, int b=2);  

解答：对于一个类X, 如果一个构造函数的第一个参数是下列之一:
a) X&
b) const X&
c) volatile X&
d) const volatile X&
且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数.
[c-sharp] view plaincopy
  1. X::X(const X&);  //是拷贝构造函数      
  2. X::X(X&, int=1); //是拷贝构造函数     
  3. X::X(X&, int a=1, int b=2); //当然也是拷贝构造函数  

3. 一个类中可以存在多于一个的拷贝构造函数吗?
解答：类中可以存在超过一个拷贝构造函数。
[c-sharp] view plaincopy
  1. class X {   
  2. public:         
  3.   X(const X&);      // const 的拷贝构造  
  4.   X(X&);            // 非const的拷贝构造  
  5. };  

注意,如果一个类中只存在一个参数为 X& 的拷贝构造函数,那么就不能使用const X或volatile X的对象实行拷贝初始化.
[c-sharp] view plaincopy
  1. class X {      
  2. public:  
  3.   X();      
  4.   X(X&);  
  5. };      
  6.   
  7. const X cx;      
  8. X x = cx;    // error  

如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝构造函数。
这个默认的参数可能为 X::X(const X&)或 X::X(X&),由编译器根据上下文决定选择哪一个。

转自：http://blog.csdn.net/lwbeyond/article/details/6202256



	
				
		









 怎么找淘宝代理商
    		怎么找淘宝代理商



原创粉丝点击



		

热门IT博客


卡尔曼滤波器算法实现卡尔曼滤波器算法实现




察一叶落而知秋察一叶落而知秋




windows安装snmp




悍将传世源码delphi




淘宝联盟怎么贷款




c4d r18 mac 意外退出




江阴海数据




淘宝店装修教程视频




如何进去网站数据库




腹黑兔2017知乎




移动网络线路转换器




windows phone 10 sdk




东方有线 有线通 知乎




网络民族志研究方案




linux 怎么看报错日志




mac版百度云盘播放视频




拦截弹出广告软件




单片机有哪些型号




淘宝客返利海报




想开淘宝店没有货源



		

热门问题
    老师的惩罚
    人脸识别
    我在镇武司摸鱼那些年
    重生之率土为王
    我在大康的咸鱼生活
    盘龙之生命进化
    天生仙种
    凡人之先天五行
    春回大明朝
    姑娘不必设防，我是瞎子
    蜻蜓小时候
    蛇蜻蜓
    一只蜻蜓
    纸蜻蜓
    蜻蜓的本领
    蜻蜓眼睛
    蜻蜓卵
    皇蜻蜓
    蜻蜓的作用
    放飞蜻蜓
    蜻蜓月季
    蜻蜓故事
    tombow 蜻蜓
    关于蜻蜓
    蜻蜓手机
    巨型蜻蜓
    红色蜻蜓
    蜻蜓作文
    蜻蜓照片
    蜻蜓飞飞
    手工蜻蜓
    蜻蜓几条腿
    梦见蜻蜓
    卡通蜻蜓
    蜻蜓寓意
    蓝色蜻蜓
    蜻蜓 英语
    蜻蜓 英文
    蜻蜓画法
    蜻蜓的翅膀
    工笔蜻蜓
    蜻蜓的特征
    红蜻蜓网站
    红色的蜻蜓
    蜻蜓的样子
    红蜻蜓沙发
    折纸蜻蜓
    机器蜻蜓
    蜻蜓的画法
    路过蜻蜓
    蜻蜓在线


	










程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里