c++：const、初始化、copy构造/析构/赋值函数
构造函数
Default构造函数：可被调用而不带任何实参的构造函数，没有参数或每个参数都有缺省值。如：
class A { public: A(); };
将构造函数声明为explicit，可阻止它们被用来执行隐式类型转换，但仍可用来进行显示类型转换。如：
class B { public: explicit B(int x = 0, bool b = ture); };
copy构造函数：用于以同型对象初始化自我对象，以passed by value的方式传递对象；·
copy assignment操作符：用于从另一个同型对象中拷贝其值到自我对象。如：
class Widget { public: Widget(); Widget(const Widget& rhs); //copy构造函数 Widget& operator=(contst Widget& rhs);//copy assignment操作符 }; Widget w2(w1); //调用copy构造函数 w1 = w2; //没有新对象被定义 调用copy assignment（copy赋值）操作 Widget w3 = w2; //有新对象被定义 调用copy构造函数
其它笔记
TR1：Technical Rpeort1，描述加入C++标注你程序库的诸多新机能的规范，机能以新的class templates和function templates形式体现，TR1组件置于命名空间std内嵌套的命名空间tr1中；
Boost：组织/网站，提供可移植的开源C++程序库，大多数TR1机能以Boost为基础。
C++可主要分为4个sublanguage部分：
1. C，以C为基础，包含blocks, statements, preprocessor, built-in data types, arrays, pointers等内容。
2. Object-oriented C++，包含C with classes的面向对象诉求，如classes（构造函数和析构函数）, encapsulation, inheritance, polymorphism（多态）, virtual函数（动态绑定）等。
3. Template C++，包含泛型编程（generic programming）部分。
4. STL，template程序库，包含containers, iterators, algorithms, function objects等内容。
C++高效编程守则的变化取决于使用的是C++的哪一部分。
注意：尽量以const, enum, inline替换#define，降低对预处理器的需求
如：以const常量替换#define
/*#define不被视为语言的一部分，记号名称ASPECT_RATIO可能没进入记号表（symbol table）内；*/ #define ASPECT_RATIO 1.653; //错误 /*语言常量Aspect肯定会被编译器看到，进入记号表内：*/ const double AspectRatio = 1.653; //正确
定义常量指针时，因为常量定义是通常被放在头文件内，有必要将指针声明为const：
const char* const authorName = “Scott Meyers”;
另：string对象通常比char*-based更合适：
const std::string authorName(“Scott Meyers“);
用static const定义class专属常量
定义class专属常量时，为确保此常量至多只有一份实体，将其作为static成员：
class GamePlayer { private: static const int NumTurns = 5;//常量声明式 int scores[NumTurns];//使用常量 };
如果需要取class专属常量的地址，需要为编译器提供class专属常量的定义式；
定义式需放入实现文件，而非头文件；
class常量在声明时获得初值，定义时不可再设初值：
cons tint GamePlayer::NumTurns;//常量定义式
如果使用旧式编译器，则不允许static成员在声明时获得初值，另in-class初值设定也只允许对整数常量进行，可采用：
class CostEstimate { private: static const double FudgeFactor; }; //常量定义位于实现文件内,赋初值 const double ConstEstimate::FudgeFactor = 1.35;
若编译器不允许in class初值设定，用enum hack补偿
Enum hack：类似#define，取#define和enum地址不合法，而取const地址合法；
Enum和#define不会导致非必要的内存分配；
可约束使别人无法获得指向某个指针常量的指针或引用；
如果编译器错误地不允许in class初值设定，可改用enum hack补偿做法，使该常量成为一个记号名称：
class GamePlayer { private: enum {NumTurns = 5}; int socres[NumTurns]; };
使用template inline函数替代宏：
template<typename T> inline void callWithMax(const T& a, const T& b) { f(a>b?a:b); }
尽可能使用const
用const来修饰指针，可以指出指针自身和其所指物是否为const。
如果关键词const出现在星号左边，表示被指物是常量；如果出现在星号右边，表示指针自身是常量；如果出现在星号两遍，表示被指物和指针两者都是常量：
char* p = greeting; //non-const pointer, non-const data const char* p = greeting; //non-const pointer, const data char* const p = greeting; //const pointer, non-const data const char* const p = greeting;//const pointer, const data
如果被指物是常量，关键词const写在类型或写在类型时候星号之前的意义都相同：
void f1(const Widget* pw); void f2(Widget const * pw);//两种都表示获得一个指针，指向常量Widget对象
STL中迭代器的作用相当于T*指针，声明迭代器为const相当于声明一个T* const指针，表示该迭代器不得指向不同的东西，但所指东西的值可以改动：
const std::vector<int>::iterator iter = vec.begin();//声明迭代器为const *iter=10; //可行
如果希望迭代器所指东西不可改动，即模拟const T*指针，则声明const_iterator：
std::vector<int>::const_iterator cIter = vec.begin(); *iter=10;//不可行
确定对象被使用前已经被初始化
C++规定对象的成员变量初始化动作发生在进入构造函数本体之前。如果按照以下操作，只是在构造函数体内赋值，而不是初始化：
ABEntry::ABEntry(const std::string& name, const std::string& address, const std::list<PhoneNumber>& phones) { theName = name; theAddress = address;//赋值（assignments） thePhones = phones; //而不是初始化（initializations） numTimesConsulted = 0; }
完成初始化更好的做法是使用成员初值列（member initialization list：
ABEntry::(const std::string& name, const std::string& address, const std::list<PhoneNumber>& phones) :theName(name), :theAddress(address), :thePhones(phones), :numTimesConsulted(0) {}
C++有固定的成员初始化次序：base classes初始化早于其derived classes，class成员变量初始化顺序按照声明次序（即使在成员初值列中次序不同，但最好以声明次序写成员初值列。
有关“不同编译单元内定义的non-local static对象”的初始化顺序
Static对象的寿命从被构造出来直到程序结束为止，包括global对象、定义于namespace作用域内的对象、classes内、函数内、file作用域内被声明为static的对象；
函数内的static对象称为local static对象，其他static对象称为non-local static对象；
程序结束时static对象会被自动销毁；
编译单元（translation unit）：产出单一目标文件（single object file）的源码；
问题：如果某个编译单元内某个non-local static对象的初始化动作使用了另一编译单元内的某个non-local static对象，因为C++对“定义于不同编译单元内的non-local static对象的初始化次序”无明确定义，它所用到的这个对象可能尚未被初始化。
解决办法：将每个non-local static对象搬到自己专属函数内，该对象在此函数内被声明为static，函数返一个指向它所含对象的reference；
用户调用这些函数，而不直接指涉这些对象（用local-static替换non-local static）；
原理：Singleton模式的一个实现收发，保证函数内的local static对象会在函数调用期间首次遇上该对象定义式时被初始化，如：
FileSystem& tfs() { static FileSystem fs; //替换local static tfs return fs; } Directorry::Directory(params) { std::size_t disks = tfs(). numDisks();//原先使用reference to tfs } Directory& tempDir() { static Directory td; //替换local static tempDir reutrn td; }
C++自动编写并调用copy构造/析构/copy赋值运算
如果没有声明copy构造函数、copy assignment操作符和析构函数，C++处理后编译器将自动声明copy构造函数和析构函数；
编译器自动声明的copy构造函数单纯将来源对象的每个non-static成员变量（调用成员变量的copy构造函数）拷贝到目标对象；
编译器自动声明的copy assignment操作符与copy构造函数类似，但如果生成代码不合法，编译器会拒绝自己生成operator=编译赋值行为，如以下三种情况：
1. 如果要在内含reference成员的class内支持赋值操作，编译器拒绝生成copy assignment，必须自己定义copy assignment操作符；
2. 如果要在内含const成员的class内支持赋值操作，更改const成员不合法，编译器拒绝生成copy assignment；
3. 如果base class将copy assignment操作符声明为private，编译器拒绝为其derived classes生成copy assignment操作符，因为所生成的copy assignment操作符将无法调用derived class无权调用的成员函数；
如果没有声明任何构造函数，编译器也会声明一个default构造函数；
这些函数都是public且inline的，当需要调用这些函数时才会被编译器创建；
编译器调用的析构函数是non-virtual的，除非该class的base class自身声明有virtual析构函数；
若不想使用编译器自动生成的函数需明确阻止
特定对象可能需要阻止对其进行copy操作，如果需要阻止编译器自动生成的函数（如copy构造函数或copy assignment操作符），可以将这些函数声明为private且不添加定义；
例：C++标准程序库iostream实现码中的ios_base, basic_ios, sentry的copy构造函数和copy assignment操作符都被声明为private且没有定义；
防止编译器暗自生成及他人调用，可将copy构造函数和copy assignment操作符声明为private，客户企图拷贝对象时会被编译器阻止：
class HomeForSale { public: ... private: ... HomeForSale(const HomeForSale&); //只有声明 HomeForSale(const HomeForSale&); };
防止member和friend函数调用，可不为copy构造函数和copy assignment操作符添加定义，但报错会发生在连接器。为将连接期错误移至编译器，可为对象创建base class，在base class内将copy构造函数和copy assignment操作符声明为private：
class Uncopyable { //base class protected: Uncopyable(){} //允许derived对象构造和析构 ~Uncopyable(){} private: Uncopyable(const Uncopyable&); //但阻止copying Uncopyable operator=(const Uncopyable&); }; class HomeForSale : private Uncopyable { //derived class ... //不再声明copy构造函数或copy assignment操作符 }
为多态基类声明virtual析构函数
注意将多态基类的析构函数声明为virtual，因为如果base class有non-virtual的析构函数，derived class对象的析构函数未能执行，derived成分无法经由base class指针销毁，形成资源泄露；
给base class声明virtual析构函数，删除derived class对象时能够完整销毁整个对象：
class TimeKeeper { public: TimeKeeper(); virtual ~TimeKeeper(); ... }; TimeKeeper* ptk = getTimeKeeper();//从TimeKeeper继承体系获得一个动态分配对象 ... delete ptk;//释放避免资源泄露
Virtual函数的实现细节：每个带有virtual函数的class都有相应的由函数指针构成的数组vtbl（virtual table）。对象携带vptr（virtual table pointer）指针，指向vtbl。当对象调用某一virtual函数时，实际被调用的函数取决于该对象的vptr所指的vtbl，编译器在vtbl中寻找适当的函数指针。
如果class不需要作为base class（class内往往不含有virtual函数），则不需要令其析构函数为virtual。
标准容器如string，STL容器如vector, list, set, trl::unordered_map等都不含有virtual析构函数，应避免继承此类带有non-virtual析构函数的class导致析构函数未有定义出现资源泄露问题。
如果需要创建抽象（abstract）对象，可为其声明pure virtual函数并提供空白定义：
class AWOV { public: virtual ~AWOV() = 0; }; AWOV::~AWOV() {}
析构函数的运作方式：最深层派生（most derived）的class的析构函数最先被调用，每个base class逐渐被调用，为derived classes的析构函数提供定义，创建对~baseclass的调用动作（否则连接器报错）。
析构函数绝对不要吐出异常
注意：析构函数绝对不要吐出异常，否则会导致程序过早结束或不明确行为。如果一个被析构函数调用的函数可能抛出异常，析构函数内应该捕捉任何异常，吞下或结束程序。
如果客户需要对某个操作函数运行期间抛出的异常做出反应，class应提供一个普通函数（在析构函数之外）执行该操作。如：
class DBConnection { public: ... static DBConnection cereate(); void close();//关闭连接，失败则抛出异常 } class DBConn { //用于管理DBConnection对象 public: ... void close() {//供客户对可能出现的问题做出反应 db.close(); //确保数据库连接关闭 close = true; } ~DBConn() { if(!closed) { try { db.close(); } catch(...) { ...//如果关闭失败，记录下来并吞下异常，或结束程序 } } } private: DBConnection db; bool closed; }; //客户使用 { DBConn dbc(DBConnection::create()); ...}//区块结束，DBConn销毁
绝对不要在构造函数和析构函数内调用virtual函数
由于无法在构造和析构期间无法使用virtual函数从base class向下调用到derived class，如果需要确保每次base class的继承体系上的对象被创建时都会有适当版本的成员函数被调用，可采用将该函数改为non-virtual，要求derived class构造函数传递必要信息给base class构造函数，构造函数从而安全调用non-virtual函数的做法：
class Transaction {//base class public: explicit Transaction(const std::string& logInfo); void logTransaction(const std::string& logInfo) const; //根据不同类型做出不同的日志记录 ... }; Transaction::Transaction(const std::string& logInfo) { ... logTransaction(logInfo); } class BuyTransaction : public Transaction { //derived class public: BuyTransaction(parameters) : Transaction(createLogString(parameters)) {...} //将log信息传给base class构造函数 ... private: static std::string createLogString(parameters); };
利用辅助函数static std::string createLogString(parameter)创建一个值传给base class构造函数，比在成员初值列内给予base class所需数据更方便、可读；
此函数为static，避免了意外指向“初期未成熟的derived class对象内尚未初始化的成员变量”。
operator=应返回*this的引用
标准赋值oprator=及其他赋值如+=,-=,*=等应遵守协议返回reference to *this（指向左侧【当前】对象的reference），从而实现“连锁赋值”（如x=y=z=15，解析为右结合律）；
class Widget { public: ... Widget& operator=(const Widget& rhs) { ... return *this; //返回类型为指向当前对象的reference } }
非强制性，违反协议一样可通过编译，但该协议被所有内置类型和标准程序库共同遵守；
在编写operator=时需考虑自我赋值操作的情况，如：
w=w;
a[i] = a[j] （i=j时）
*px = *py; （px和py指向同一处）忽略自我赋值问题指针可能指向已被删除的对象；
处理方法：提前做证同测试（identity test），检验自我赋值情况：
Widget& Widget::operator(const Widget& rhs) { if (this == &rhs) return this; //identity test delete pb; //pb为对象持有的指针 pb = newBitmap(*rhs.pb); return *this; }
仍存在不具备异常安全性的问题，如果因为分配时内存不足或copy构造函数抛出异常导致new()异常，持有指针可能仍会指向已被删除的对象；
让operator具备异常安全性的做法：在复制指针所指对象前先别delete该指针，如果new()抛出异常，指针和指针原指的对象能够保持原状。
Widget& Widget::operator=(const Widget& rhs) { If(this==&rhs) return *this; Bitmap* pOrig = pb; //记住原先持有的指针 pb = new Bitmap(*rhs.pb) //令pb指向*pb的一个副本 delete pOrig; //删除原先的pb return this; }
复制对象时需注意复制所有成分
为derived class编写copying函数时需要记得除local成员变量外，还需复制base class成分，其中base class的private成分无法直接访问，应在derived class的copying函数内调用相应的base class函数：
PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs) : Customer(rhs), PriorityCustomer(rhs.priority) { //调用base class Customer的构造函数 logCall("PriorityCustomer copy constructor"); } PriorityCustomer& PriorityCustomer::operator=(const PriorityCustomer& rhs) { logCall("PriorityCustomer copy assignment operator"); Customer::operator=(rhs); //对base class成分进行赋值 return *this; }
