C++对象的直接初始化和复制初始化

References:

1. http://www.cnblogs.com/chio/archive/2008/10/06/1305145.html
   
2. http://stackoverflow.com/questions/1051379/is-there-a-difference-in-c-between-copy-initialization-and-direct-initializatio
   

---

 先来个区别说明：赋值操作是在两个已经存在的对象间进行的，而初始化是要创建一个新的对象，并且其初值来源于另一个已存在的对象。编译器会区别这两种情 况，赋值的时候调用重载的赋值运算符，初始化的时候调用拷贝构造函数。如果类中没有拷贝构造函数，则编译器会提供一个默认的。这个默认的拷贝构造函数只是 简单地复制类中的每个成员。 下面看例子。   

c++中初始化和赋值操作差别是很大的。  
对于基本数据类型差别不大：  
比如：  
int a = 12; // initialization, copy 0X000C to a  
a = 12; // assignment, copy 0X000C to a  
但是对用户自定义的数据类型比如String 初始化和赋值就差别很大：  
class String ...{  
 public:  
 String( const char *init ); // intentionally not explicit!  
 ~String();  
 String( const String &that );  
 String &operator =( const String &that );  
 String &operator =( const char *str );  
 void swap( String &that );  
 friend const String // concatenate  
 operator +( const String &, const String & );  
 friend bool operator <( const String &, const String & );  
 //...  
 private:  
 String( const char *, const char * ); // computational  
 char *s_;  
};  
初始化的构造过程比较简单：先分配一个足够大的空间然后填充上数据：  
String::String( const char *init ) ...{  
 if( !init ) init = """";  
 s_ = new char[ strlen(init)+1 ];  
 strcpy( s_, init );  
}  
析构过程更简单：  
String::~String() ...{ delete [] s_; }  

但是如果赋值操作就复杂多了：  
String &String::operator =( const char *str ) ...{  
  
 if( !str ) str = """";  
  
 char *tmp = strcpy( new char[ strlen(str)+1 ], str );  // 多了中间变量  
  
 delete [] s_;　// 多了删除s_;  
 s_ = tmp;  　// 多一个赋值操作！现在是指向字符的指针，如果是个大对象，效率的差别可想而知．  
  
 return *this;  
}

 C＋＋初始化语法的不一致性：

C语言确实很优雅，整个语言的设计简洁一致。而在C++中，有一个让人诟病的问题就是变量初始化的不一致性。

   C语言中的初始化，都是用花括号进行，简单美观：

int  array[]  =  { 1 , 2 , 3 , 4 , 5 };
struct  Point point  =  { 2 ,  3 };
struct  Point arrPoint[]  =  
{
  { 2 , 3 },
  { 4 , 5 },
  { 6 , 7 }
};

   C++自然也兼容了C语言的初始化机制。然而，C++的Class乃至STL都不支持。它们要用不同的方式来初始化， 甚至根本不能够直接初始化， 只能使用运行时的赋值。
   比如Class：

class  Param
{
public :
   int  Age;
   int  Value;
private :
   int  Level;
};

Param param  =  { 2 , 3 };  //  ERROR
Param param  =  { 2 , 3 , 4 };  // ERROR

   无法初始化。而如果不初始化的话，所有的成员而处于无政府状态，这显然很不让人放心。于是，C++提供了专门用于Class的初始化方式－－构造函数：

class  Param
{
public :
  Param( int  x,  int  y)
    : x_(x), y_(y)
  {}
  Param()
    : x_( 0 ), y_( 0 )
  {}
private :
   int  x_, y_;
};

Param param( 1 , 2 );
// 或
Param param;

   有了构造函数，可以在构造函数的初始化列表中对成员进行初始化。可是很明显，这里头还是有一个陷阱，默认构造初始化和非默认构造初始化的调用方式是不一致的。默认构造函数不能用括号来调用，否则编译器将会发疯：

Param param();

   它会把上面的语句看成是函数声明，而后面调用的时候就会出错，而错误信息可能会让你抓狂一下。但是这样也就算了，偏偏 new 可以接受有括号和没括号两种写法：

Param *  p1  =  new  Param;
Param *  p2  =  new  Param();

   再来说说初始化列表。初始化列表，事实上，也只能支持简单的标量类型，诸如int,bool,指针之类的；复杂点的，如数组、结构，不好意思，不支 持－－只能在构造函数体中进行赋值。还有一个很迷糊初学者的问题是，成员初始化的顺序仅依赖于成员定义的顺序，而不是初始化列表中的顺序。

   再比如STL容器，这下好象更惨，连构造函数都帮不上忙了，除了初始化一个空的容器，或是复制一下别的容器，我们只能做用默认构造函数进行初始化。我们拿数组和vecotr做个比较：

//  数组
int  arr[] = { 1 , 2 , 3 , 4 };
//  vector
vector < int >  iarr;
//  必须在某个函数中赋初值
void  init()
{
   for ( int  i  =  1 ; i  <=  4 ;  ++ i) 
    iarr.push_back(i);
}

   再复杂一点的数据结构，那单单赋值程序就要写上老长，而且还不好看。还要记得调用。这对于仅仅是简单的设置一些初值的用途来说，太过于烦琐。

   横向比较，这次好象C++还不会太落伍，只有C和动态语言提供了初始化特性，其它支持OO高级语言好象都是学C++的。如Java, C#(注C#3.0开始提供初始化功能)...
   
   C++能不能做到简洁一致的实始化呢？
   Boost的assign库做了许多有益的工作。使用assign库，至少现在可以初始化了： 

vector < int >  arr  =  list_of( 1 )( 2 )( 3 )( 4 );   

typedef boost::tuple < int ,std:: string , int >  tuple;
vector < tuple >  v  =  tuple_list_of(  1 ,  " foo " ,  2  )(  3 ,  " bar " ,  4  );

map < int , int >  next  =  map_list_of( 1 , 2 )( 2 , 3 )( 3 , 4 )( 4 , 5 )( 5 , 6 );

stack < string >  names  =  list_of(  " Mr. Foo "  )(  " Mr. Bar " )(  " Mrs. FooBar "  ).to_adapter();

   如果是赋值，也可以简略很多：

vector < int >  v;
v  +=  1 , 2 , 3 ,repeat( 10 , 4 ), 5 , 6 , 7 , 8 , 9 ;
//  v = [1,2,3,4,4,4,4,4,4,4,4,4,4,5,6,7,8,9]

  不过，也仅能如此了。assign经过许多努力，也仅能支持容器的初始化，而且还不够漂亮。

   C++0x已确定提供与C一致的初始化功能。  Initialer lists  Initializer Lists for Standard Containers  Initializer lists WP wording 等草案就是为了这个目的服务的。
   如果使用C++0x，那么程序的初始化将变得清晰和一致：

complex < double >  z  =  { 1 , 2 }; 
// 或
complex < double >  z { 1 , 2 }; 
//  初始化中，有等号和无等号都是允许的，下同。
z  +=  { 2 , 3 };

int  a  =  { 1 }; 

new  vector < string > { " once " ,  " upon " ,  " a " ,  " time " }; 

f( { " Nicholas " ,  " Annemarie " } );  //  参数是两个元素的列表

return  {  " Norah "  };  //  返回只有一个元素的列表
 
int *  e {};   //  初始化为0或NULL指针

map < string , int >  anim  =  
{ 
  { " bear " , 4 }, 
  { " cassovary " , 2 }, 
  { " tiger " , 7 } 
}; 

   这好象是C++欠了十多年的债吧。