构造函数详解_const的部分分析，部分转载于http://ticktick.blog.51cto.com/823160/194307

c++构造函数的知识在各种c++教材上已有介绍，不过初学者往往不太注意观察和总结其中各种构造函数的特点和用法，故在此我根据自己的c++编程经验总结了一下c++中各种构造函数的特点，并附上例子，希望对初学者有所帮助。

c++类的构造函数详解

一、 构造函数是干什么的

class Counter
{

public:
// 类Counter的构造函数
// 特点：以类名作为函数名，无返回类型
Counter()
{
m_value = 0;
}

private:

// 数据成员
int m_value;
}

该类对象被创建时，编译系统对象分配内存空间，并自动调用该构造函数->由构造函数完成成员的初始化工作

eg: Counter c1;

编译系统为对象c1的每个数据成员(m_value)分配内存空间，并调用构造函数Counter( )自动地初始化对象c1的m_value值设置为0

故：

构造函数的作用：初始化对象的数据成员。

二、 构造函数的种类

class Complex
{

private :
double    m_real;
double    m_imag;

public:

//    无参数构造函数
// 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做
// 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来
Complex(void)
{
m_real = 0.0;
m_imag = 0.0;
}

//    一般构造函数（也称重载构造函数）
// 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）
// 例如：你还可以写一个 Complex( int num)的构造函数出来
// 创建对象时根据传入的参数不同调用不同的构造函数
Complex(double real, double imag)
{
m_real = real;
m_imag = imag;
}

//    复制构造函数（也称为拷贝构造函数）
//    复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
//    若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询 有关 “浅拷贝” 、“深拷贝”的文章论述
Complex(const Complex & c)
{
// 将对象c中的数据成员值复制过来
m_real = c.m_real;
m_img    = c.m_img;
}

// 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象
// 例如：下面将根据一个double类型的对象创建了一个Complex对象
Complex::Complex(double r)
{
m_real = r;
m_imag = 0.0;
}

// 等号运算符重载
// 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建
// 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作
Complex &operator=( const Complex &rhs )
{
// 首先检测等号右边的是否就是左边的对象本，若是本对象本身,则直接返回
if ( this == &rhs )
{
return *this;
}

// 复制等号右边的成员到左边的对象中
this->m_real = rhs.m_real;
this->m_imag = rhs.m_imag;

// 把等号左边的对象再次传出
// 目的是为了支持连等 eg:    a=b=c 系统首先运行 b=c
// 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)
return *this;
}

};

下面使用上面定义的类对象来说明各个构造函数的用法：

int main()
{
// 调用了无参构造函数，数据成员初值被赋为0.0
Complex c1，c2;

// 调用一般构造函数，数据成员初值被赋为指定值
Complex c3(1.0,2.5);
// 也可以使用下面的形式
Complex c3 = Complex(1.0,2.5);

//    把c3的数据成员的值赋值给c1
//    由于c1已经事先被创建，故此处不会调用任何构造函数
//    只会调用 = 号运算符重载函数
c1 = c3;

//    调用类型转换构造函数
//    系统首先调用类型转换构造函数，将5.2创建为一个本类的临时对象，然后调用等号运算符重载，将该临时对象赋值给c1
c2 = 5.2;

// 调用拷贝构造函数( 有下面两种调用方式)
Complex c5(c2);
Complex c4 = c2;  // 注意和 = 运算符重载区分,这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c2
return 0;

}

三、浅拷贝与深拷贝

上面提到，如果没有自定义复制构造函数，则系统会创建默认的复制构造函数，但系统创建的默认复制构造函数只会执行“浅拷贝”，即将被拷贝对象的数据成员的值一一赋值给新创建的对象，若该类的数据成员中有指针成员，则会使得新的对象的指针所指向的地址与被拷贝对象的指针所指向的地址相同，delete该指针时则会导致两次重复delete而出错。下面是示例：

【浅拷贝与深拷贝】

#include <iostream>
#include <string>
class Person
{
public :

// 构造函数
Person(char * pN)
{
cout << "一般构造函数被调用 !\n";
m_pName = new char[strlen(pN) + 1];
//在堆中开辟一个内存块存放pN所指的字符串
if(m_pName != NULL)
{
//如果m_pName不是空指针，则把形参指针pN所指的字符串复制给它
strcpy(m_pName ,pN);
}
}

// 系统创建的默认复制构造函数，只做位模式拷贝
Person(Person & p)
{
//使两个字符串指针指向同一地址位置
m_pName = p.m_pName;
}

~Person( )
{
delete m_pName;
}

private :

char * m_pName;
};

void main( )
{
Person man("lujun");
Person woman(man);

// 结果导致   man 和    woman 的指针都指向了同一个地址

// 函数结束析构时
// 同一个地址被delete两次
}
//以上编译虽然能通过，但是编译器不会执行函数的功能，即主函数没有被运行

// 下面自己设计复制构造函数，实现“深拷贝”，即不让指针指向同一地址，而是重新申请一块内存给新的对象的指针数据成员
{
// 用运算符new为新对象的指针数据成员分配空间
m_pName=new char[strlen(chs.m_pName)+ 1];

if(m_pName)
{
// 复制内容
strcpy(m_pName ,chs.m_pName);
}

// 则新创建的对象的m_pName与原对象chs的m_pName不再指向同一地址了
}

另加的一部分内容—const的简单分析

我们来看下边例子，我把这个代码都贴过来了

它是分析类的成员函数test1（），test2（），test3（），test4（），test5（）和复制构造函数的调用问题。

#include<iostream>
#include <string>
using namespace std;
class Complex
{
public:
double m_real;
double m_imag;
public:
Complex();
Complex(double real,double imag);
Complex(const Complex &st);
const Complex &test1(const Complex& c)
{
/*c.m_real=1.0;*/    //如果包含此句就会出错
return c;
}
Complex test2(const Complex& c)
{
/* c.m_real=1.0; */
return c;
}
Complex test3(const Complex c)
{

return c;
}
Complex test4()
{
static Complex c(1.0,5.0);
return c;
}
Complex& test5()
{
static Complex c(1.0,5.0);
return c;
}
};

Complex::Complex()
{
m_real=0.0;
m_imag=0.0;
}
Complex::Complex(double real,double imag)
{
m_real=real;
m_imag=imag;
}
Complex::Complex(const Complex &st)
{
m_real=st.m_real;
m_imag=st.m_imag;
}

int main()
{
Complex c1,c2,c3,c4,c5,c6;
c1=Complex(1.0,2.0);
cout.setf(ios::fixed);
c2.test1(c1);//形参c是实参c1的常量引用，常量说明test1（）函数体里不能对c进行修改；引用说明
//不需要调用复制构造函数将c1赋值给c。test1（）的返回值是也是常量引用，即c是c2的
//常量引用，返回c时不会调用复制构造函数将c赋值给c2，而是通过引用赋值
c3.test2(c1);//形参实参的分析同test1（），执行到return c；语句时，调用复制构造函数将c赋值给c3
c4.test3(c1);//这句共调用两次复制构造函数，一次发生在形参实参的传递，一次发生在return c；语句
c5.test4();//调用一次默认构造函数，一次复制构造函数，发生在return c；
c6.test5();//函数返回值是引用，故在执行return c；语句时不再调用复制构造函数。
c2.m_real=4.4;//还未解决的问题，按函数返回值来看，c2为一const类型，但此句还是可以执行的，c2的值可修改？
return 0;
}

拿c4.test3(c1);来说明调用的过程，调试下可以看到整个过程。当执行到此句时，首先是实参转化为形参，这里是值传递，故先调用一次复制构造函数，将实参传递给形参，如果形参是实参的引用，这里就不会调用复制构造函数了；其次，执行return c;语句，将c返回给c4，这里再次调用一次复制构造函数，如果函数的返回值为引用，如test1（），这里就不会再调用复制构造函数了。

未解决的问题：可能对const理解不够深入，故语句c2.m_real=4.4;还没能搞明白。