Use

    public class BookChapter
    {
        public string book_id;
        public string book_name;
        public string chapter_num;
        public string chapter_title;
        public string chapter_Url;
        public string chapter_content;


        public BookChapter(BookChapter bc)
        {
            bc.CopyPublicFieldTo(this);
        }
}

 实现

    /// <summary>
    /// 反射实现类的对象之间相同属性值的复制, s => d
    /// </summary>
    /// <typeparam name="D"></typeparam>
    /// <typeparam name="S"></typeparam>
    /// <param name="s"></param>
    /// <returns></returns>
    public static void  CopyPropertiesTo<D>(this object s, D d)
    {
        try
        {
            var Types = s.GetType();//获得类型
            var Typed = d.GetType();
            foreach (PropertyInfo sp in Types.GetProperties())//获得类型的属性字段
            {
                foreach (PropertyInfo dp in Typed.GetProperties())
                {
                    if (dp.Name == sp.Name)//判断属性名是否相同
                    {
                        dp.SetValue(d, sp.GetValue(s, null), null);//获得s对象属性的值复制给d对象的属性
                    }
                }
            }
        }
        catch (Exception e)
        {
            throw e;
        }
    }

    /// <summary>
    /// 反射实现类的对象拷贝相同字段值的复制, s => d
    /// </summary>
    /// <typeparam name="D"></typeparam>
    /// <param name="s">源头</param>
    /// <param name="d">目标</param>
    public static void CopyPublicFieldTo<D>(this object s,D d)
    {
        try
        {
            var Types = s.GetType();//获得类型
            var Typed = d.GetType();
            foreach (var sp in Types.GetFields(BindingFlags.Public | BindingFlags.Instance))//获得类型的属性字段
            {
                foreach (var dp in Typed.GetFields(BindingFlags.Public | BindingFlags.Instance))
                {
                    if (dp.Name == sp.Name)//判断名是否相同
                    {
                        dp.SetValue(d, sp.GetValue(s));//获得s对象属性的值复制给d对象的属性
                    }
                }
            }
        }
        catch (Exception e)
        {
            throw e;
        }
    }

 

简述


复制构造函数是一种特殊构造函数，在生成一个实例时，一般会同时生成一个默认的复制构造函数，复制构造函数完成一些基于同一类的其他对象的构建及初始化工作。




特点


复制构造函数名与类名同名，因为它是一种构造函数，并且函数不指定返回类型。
该函数只有一个参数，并且是某个对象的引用。
每个类都必须有一个复制构造函数。如果程序员没有显式地定义一个复制构造函数，C++编译器会自动生成一个缺省的复制构造函数。
复制构造函数需要考虑深拷贝和浅拷贝的问题，默认构造函数只进行浅拷贝，当我们的类私有数据成员中含有指着类型时，需要进行深拷贝，即显式地定义复制构造函数。




#include<iostream>

using namespace std;

class A {
public:
    A(int val) :a(val) {
        p = new int(a);
    }
    A(const A& it) {
        a = it.a;
        delete p;
        p = new int(a);
        cout << it.p << endl;  //0051C0B8
        cout << p << endl;     //0051C0E8
    }
    int get() {
        return *p;
    }
private:
    int a;
    int *p;
};

int main(int argc, char* argv[]) {
    A A1(10);
    A A2(A1);
    cout << A2.get() << endl;  //10
    getchar();
    return 0;
}



复制构造函数和赋值运算符的区别


复制构造函数生成新的类对象，而赋值运算符不能。
当类中有指针类型的成员变量时，一定要重写复制构造函数和赋值运算符，不能使用默认的。
当进行一个类的实例初始化时，也就是构造时，调用的是构造函数，但如果用其他实例来初始化，则调用的是复制构造函数，非初始化时这个实例进行赋值调用的是赋值运算符。（重要！！！）




#include<iostream>

using namespace std;

class A {
public:
    A(int val) :a(val) {
        p = new int(a);
    }
    A(const A& it) {
        cout << "复制构造函数" << endl;
        a = it.a;
        delete p;
        p = new int(a);
        cout << it.p << endl;  
        cout << p << endl;     
    }
    A& operator=(const A& it) {
        cout << "赋值运算符" << endl;
        a = it.a;
        delete p;
        p = new int(a);
        cout << it.p << endl;  
        cout << p << endl;    
        return *this;
    }
    int get() {
        return *p;
    }
private:
    int a;
    int *p;
};

int main(int argc, char* argv[]) {
    A A1(10);
    A A3(30);
    A A2 = A1;
    A2 = A3;
    cout << A2.get() << endl; 
    getchar();
    return 0;
}



扩展：空类默认产生哪些成员函数


默认构造函数
复制构造函数
析构函数
赋值运算符重载函数
取址运算符重载函数
const取址运算符重载函数


class A {
public:
    A();
    ~A(){}
    A(const A&);
    A& operator=(const A&);
    A* operator&();
    const A* operator&() const;
};

默认构造函数

编译器提供一个不接受任何参数，也不执行任何操作的构造函数，称之为默认构造函数

这是因为创造对象的时候总会调用默认构造函数



Klunk::Klunk() {}   //定义
Klunk lunk;         //声明  使用默认构造函数

如果定义了构造函数，C++不会定义默认构造函数，如果希望创建对象时不显示地对他进行初始化，则必须显示的定义默认构造函数，这种默认的构造函数没有任何参数，但是可以用来设定特定的值，比如说：



Klunk::Klunk() 
{
    klunk_cnt = 0;
}

带参数的构造函数也可以是默认构造函数，只要所有的参数都有默认值 

Klunk::Klunk(int n = 0)  

{ 

    klunk_cnt = n; 

}

但是注意，下面两种构造函数不能共同声明，会引起歧义

Klunk::Klunk(int n = 0) {klunk_cnt = n;}
Klunk::Klunk() {klunk_cnt = n;}

Kulnk kar (10);  //这回选择只用第一种
Kulnk bus;       //两种都可以，所以会报错





复制构造函数

// 对象的声明
Stringbad sailor = sports

上面这句话是常见的一种对象声明方式，这种对象方式使用了哪种构造函数呢？不是默认构造函数，也不是 Stringbad ::Stringbad (const char *)这种构造函数，而是等效于下面这句话



StringBad sailor = StringBad (sports)

因为sports的类型为StringBad ，所以说此时构造函数的原型如下



StringBad (const StringBad  &)

当使用一个对象初始化另一个对象的时候，编译器会自动生成构造函数，成为复制构造函数

复制构造函数用于将一个对象复制到新创建的对象中。也就是说，它用于初始化过程中(包括按值传递参数)，而不是常规的复制过程，累的复制构造函数原型：



StringBad (const Class_name &) // 他接受一个指向类的对象的常量引用作为参数

何时调用复制构造函数

 新建一个对象，并将其初始化为同类现有对象的时候，复制构造函数就会被调用，在很多情况下都可能发生，最常见的情况是将新对象显示的初始化为现有的对象。



StringBad ditto (motto)  //使用复制构造函数构造ditto
StringBad metto = motto
StringBad also = StringBad (motto)
StringBad * pStringBad = new StringBad (motto)

其中中间两种的声明可能会使用复制构造函数直接创建metto 和 also，也可能会生成一个临时对象，然后将临时兑现的内容赋值给metto 和also。最后一种是初始化一个匿名对象，并将新对象复制给指针。

 当函数按值传递对象或者函数返回对象时，都将会使用复制构造函数，每当程序生成了副本，编译器都将会使用复制构造函数


  
注意： 由于使用按值传递的时候会调用复制构造函数，那么会浪费一定的时间和空间，所以应该经常使用引用传递参数，这样的话，可以节省调用构造函数的时间以及存储空间。


默认的复制构造函数的功能 

  默认的复制构造函数逐个复制非静态成员（成员复制也成为浅复制）,复制的是成员的值。 



StringBad sailor = sports;
//与下面的函数等价
StringBad sailor;
sailor.str = sports.str;
sailor.len = sports.len;

浅复制构造函数带来的缺陷 

  浅复制构造函数会让新的对象和以前的对象使用同一个地址，那么当调用析构函数的时候，析构了一次，但是会让两个对象都失去地址，然后GG思密达

解决办法 

定义一个显示复制构造函数以解决问题 

所谓的显示复制构造函数，就是加了地址这一项。



StringBad::StringBad (const StringBad & st)
{
    num_strings++;
    len = st.len;
    str = new char [len + 1]
    std::strcpy (str, st.str);
}


  
警告：如果类中包含了使用new初始化的指针成员，应当定义一个复制构造函数，以复制指向的数据，而不是指针，这类被称为深度复制。复制的另一种形式是浅复制，只是复制指针值，浅复制仅仅浅浅的复制指针信息，而不会深入挖掘复制指针引用的结构




赋值运算符

运算符原型：



Class_name & Class_name::operator=(const Class_name &);

赋值运算符的功能以及何时使用它 

 将已有的对象赋给另一个对象时，将使用重载的赋值运算符：

StringBad headline1 ("Celery Stalks at Midnight");
StringBad knot;
knot = headline1;   // 使用复制构造函数创建一个临时对象然后通过赋值将临时对象复制到新的对象中。
/*
    这样就是说初始化总是会调用复制构造函数创建一个临时的对象。
    然后通过赋值将临时对象的值复制到新对象中。
*/

这个和上面的复制构造函数是有区别的 

复制构造函数：

// 对象的声明
Stringbad metoo= knot



这里的metto是一个新创建的对象，被初始化knot的值，因此使用复制构造函数
这里的knot是一个先使用默认构造函数创建的对象，然后使用knot对其进行赋值操作

默认赋值运算符带来的问题 

使用默认的赋值运算符所产生的问题的原因和复制运算符产生的问题原因是一样的，都是同一块地址，析构就没有了。

解决办法—-创建一个深复制函数 

实现与复制函数一样，但是也有一些小区别


由于目标对象可能引用了以前分配的数据，所以在使用之前使用delete[]进行释放
函数应当避免将对象赋值给自身，否则，给新对象重新赋值前，释放内存操作可能删除的对象
函数返回一个指向调用对象的引用。




StringBad & StringBad::operator=(const StringBad & st)
{
    if (&st == this)
        return *this;
    delete [] str;
    len = st.len;
    str = new char [len + 1];
    std::strcpy (str, st.str);
    return * this;
}

参考 《C++ Primer Plus》

C++的初学者经常会对复制构造函数一知半解，我曾经对复制构造函数和赋值函数就很是迷茫。闲来无事，整理一下，一个对象的复制构造函数和赋值构造函数。整体的说一下，复制构造函数和赋值构造函数的相同点是： 赋值运算符和复制构造函数都是用已存在的B对象来创建另一个对象A； 

最大的不同在于：赋值构造函数处理两个已有对象，即赋值前B应该是存在的；复制构造函数是生成一个全新的对象，即调用复制构造函数之前A不存在。 

- 类

首先，介绍一下类：类是数据以及用于操纵该数据的方法（函数）的集合，是逻辑上相关函数与数据的封装。它是对所要处理问题的抽象描述，它把数据（事物的属性）和函数（事物的行为/操纵）封装为一个整体。 

    类的定义格式如下：



class 类名{
private：
//私有数据和函数
protect：
//保护数据和函数
public：
//公有数据和函数
}

C++中面向对象的思想是对对象的属性（成员变量）进行操作，应该通过对象的方法（成员函数）来进行，对象的方法是对象和外部的接口。 

这里顺便说一句成员函数的定义通常的格式是：



范围值类型 类名::函数名（参数表）
{
//函数体
}

很多基础比较差的程序员，“::”符号不知道是什么意思（虽然知道也没什么用），只知道怎么用！运算符“::”成为作用域解析运算符，它指出该函数是属于哪一类的成员函数。当然也可以在类的定义中直接定义函数。所以有的时候也不用“::”符号.

对象即类的实例。创建类的对象可以常用的两种方法： 

1、直接创建对象，比如CObject类的一个对象 CObject object;（注意这里的object是一个临时对象） 

2、采用动态创建类的对象的方法，当然遍历同样也可以动态创建。



- 复制构造函数

上面说到了类，也说到了对象的创建，那么同一个类的对象在内存中有完全相同的结构，如果作为一个整体进行复制是完全可行的。这个复制的过程只需要把数据成员复制过来即可，而函数成员是可以共用的，同一个类的任何对象都可以共用这个类的函数成员。 

在建立对象时可以用同一类的另一个对象来初始化该对象，这时所用的构造函数成为复制构造函数。像X::X(X&),这种形式，且只有一个参数——同类的对象，采用的是引用的方式。不能用X::X(X)这种形式的构造函数，如果把一个真实的类的对象作为参数传递到复制构造函数，会引起无穷的递归。那很多人有不解，平常我创建类的对象的时候也没有写复制构造函数呀，为什么也没有报错呢？原因是如果没有定义的话，那么编译器生成默认复制构造函数；如果定义了地自己的复制构造函数，则默认的复制构造函数就不存在了。（这一点与析构函数不同，即使自己定义了析构函数，默认的析构函数仍然存在） 

复制构造函数在以下3中情况下会被调用：

当用一个对象去初始化同类的另一个对象时。
CObject o2(o1);
//
CObject o2=o1;

如果某函数有一个形参是类A的对象，那么该函数被调用时，类A的复制构造函数将被调用。
void Fun(CObject object)
{
    object.a=1;
}
CObject object;
Fun(object);
//CObject 的复制构造函数被调用，生成形参，在内存新建一个局部对象，并把实参复制到新的对象中。

如果函数的返回值是类CObject的对象，则函数返回时，CObject的复制构造函数被调用。理由也是建立一个临时对象，再返回调用者。
CObject Fun（）
{
    CObject object;
    return object; //在此处调用了CObject（object）
}
int main（）
{
    CObject object; //此处是一个局部对象，也是一个临时对象
    object = Fun（）; 
    return 0;
}

有人可能会问，为什么不直接用要返回的局部对象呢？因为局部对象在离开建立它的函数时就消亡了，不可能在返回调用函数后继续生存。所以编译系统会在调用函数的表达式中创建一个无名临时对象，该临时对象的生存周期只在函数调用处的表达式中。所谓返回对象，实际上就是调用复制构造函数把该对象的值复制到临时对象中。



 -赋值构造函数

首先看一段代码：



int main（）
{
    CObject theObjectOne;
    theObjectOne.Init(100);

    CObject theObjectTwo;
    theObjectTwo.Init(200);

    theObjectTwo = theObjectOne;
    //此操作是对象赋值操作，更深一步的操作时将被复制对象theObjectTwo对象原有的内容清除，并用theObjectOne对象里的内容填充。
    return 0;
}

“=”就是讲一个对象里的内容到另一个对象中去，这其中涉及到对象原有内容的丢弃和新内容的复制。由于对象内容包含指针，将造成不良的后果:指针的值被丢弃了（指针内容丢失了也就是说指针地址丢失了，但是改地址中所存储的内容没有丢失，但指针指向的内容并未释放。指针的值被复制了，但是指针所指内容并未复制，这就要出大事儿了）。所以如果类的对象中有指针的话，此处的“=”绝对不能是我们平常理解的简简单单的等于号，这个“=”必须重载，而这个“=”的重载函数就是我们要讨论的赋值构造函数。

我们再来理解两个概念：值拷贝和位拷贝，位拷贝拷贝的是地址；值拷贝拷贝的是内容。理解了这两个概念我们再看一段代码： 

定义一个string类，但是不实现其他的成员函数



Class String
{
public:
           String(const char *ch = NULL); //默认构造函数
           String(const String &str); //复制构造函数
           ~String（）;
           String &operator=(const String &str);//赋值构造函数
 privat：
            char *m_data;
}

int main()
{
    String strA;
    strA.m_data=L"Windows";
    String strB;
    strB.m_data=L"Linux";

    strB.m_data = strA.m_data;
}

如果“=”未重写赋值构造函数的话，将strA赋给strB；则编译器会默认进行位拷贝，即strB.m_data = strA.m_data; 

则strA.m_data和strB.m_data都指向了同一块区域，虽然strA.m_data指向的内容会改变为“Linux”,但是会出现这样的问题： 

（1）strB.m_data原来指向的内存区域未释放，造成内存泄露。 

（2）strB.m_data和strA.m_data指向同一块区域，任何一方改变都会影响另一方。 

（3）当对象被析构时，strA.m_data被释放两次。

如果“=”重写了复制构造函数后，strB.m_data = strA.m_data;进行的是值拷贝，会将strA.m_data的内容赋给strB.m_data,strB.m_data还是指向原来的内存区域，但是其内容改变。

所以在我理解起来，赋值构造函数其实就是对“=”的重载。缺省的赋值构造函数采用的是“位拷贝”而非“值拷贝”的方式实现。如果类中含有指针变量，那么赋值构造函数如果不重载的话肯定会出错。理解到这里，我们再回过头看一下复制构造函数，其实也是一样的道理，缺省的复制构造函数采用的也是“位拷贝”的方式实现，所以如果类中含有指针变量的话我们也需要重写复制构造函数。 

总而言之一句话，什么把你弄的这么头疼来看这篇文章，归根到底就是——指针。

最后附上一段不错的理解复制构造函数和赋值构造函数的代码：



#include <iostream>
#include <cstring>
using namespace std;

class String  
{
    public:
        String(const char *str);
        String(const String &other);
        String & operator=(const String &other);
        ~String(void); 
    private:
        char *m_data;
};

String::String(const char *str)
{
    cout << "自定义构造函数" << endl;
    if (str == NULL)
    {
        m_data = new char[1];
        *m_data = '\0';
    }
    else
    {
        int length = strlen(str);
        m_data = new char[length + 1];
        strcpy(m_data, str);
    }
}

String::String(const String &other)
{
    cout << "自定义复制构造函数" << endl;
    int length = strlen(other.m_data);
    m_data = new char[length + 1];
    strcpy(m_data, other.m_data);
}

String & String::operator=(const String &other)
{
    cout << "自定义赋值函数" << endl; 

    if (this == &other)
    {
        return *this;
    }
    else
    {
        delete [] m_data;
        int length = strlen(other.m_data);
        m_data = new char[length + 1];
        strcpy(m_data, other.m_data);
        return *this;
    }
}

String::~String(void)
{
    cout << "自定义析构函数" << endl; 
    delete [] m_data;
}
int main()
{
    cout << "a(\"abc\")" << endl;
    String a("abc");

    cout << "b(\"cde\")" << endl;
    String b("cde");

    cout << " d = a" << endl;
    String d = a;

    cout << "c(b)" << endl;
    String c(b);

    cout << "c = a" << endl;
    c = a;

    cout << endl;

执行结果

a（“abc”） 

执行自定义构造函数 

b（“ced”） 

执行自定义构造函数 

d=a 

执行自定义复制构造函数 

c（b） 

执行自定义复制构造函数 

c=a 

执行自定义赋值函数

执行自定义析构函数 

执行自定义析构函数 

执行自定义析构函数 

执行自定义析构函数

说明几点

赋值函数中，上来比较 this == &other 是很必要的，因为防止自复制，这是很危险的，因为下面有delete []m_data，如果提前把m_data给释放了，指针已成野指针，再赋值就错了
赋值函数中，接着要释放掉m_data,否则就没机会了（下边又有新指向了）
拷贝构造函数是对象被创建时调用，赋值函数只能被已经存在了的对象调用

注意：String a(“hello”); String b(“world”);  调用自定义构造函数

     String c=a；调用拷贝构造函数，因为c一开始不存在，最好写成String c(a);