Effective<1>——让自己习惯c++

<1>让自己习惯C++

条款01：视C++为一个语言联邦

今天的c++已经是个多重范型编程语言，一个同时支持过程形式、面向对象形式、函数形式、泛型形式、元编程形式的语言。主要可以分为四个次语言：

1.C。C++仍是以C为基础。区块（blocks)、语句（statements）、预处理器（perprocessor)、内置数据类型（built-in data types)、数组（arrays)、指针（pointers)等。

2.Object-Oriented C++。C with Classes所诉求的:classes(包括构造函数和析构函数)、封装（encapsulation）、继承(inheritance)、多态（polymorphism)、virtual函数（动态绑定）等。

3.Template C++。泛型编程部分。template相关考虑和设计已经弥漫整个C++。

4.STL。STL是个template程序库。它对容器（containers）、迭代器（iterators）、算法（algorithms）以及函数对象（functionobjects）的规约有极佳的紧密配合与协调。

~C++高效编程守着视状况而变化，取决于你使用C++的哪一部分。

条款02：尽量以const、enum、inline替换#define

常量替换#define有两种特殊情况。

1.定义常量指针（constant pointers），由于常量定义式通常被放在头文件内（以便不同源码含入），因此有必要将指针（非指针指向之物）声明为const。若要定义一个常量的char*-based字符串，则有：

const char* const authorName="Scott Meyers"；

或 const std::string authorName("Scott Meyers");

2.class专属常量。为了将常量的作用域（scope）限制与class内，你必须让他成为class的成员（member）：

class GamePlayer{
private:
      static const int NumTurns=5;//常量声明式
      int scores[NumTurns];//使用该常量
      ...
};

然而所写的是NumTurns的生明式而非定义式。有些编译器需要另外提供定义式：

const int GamePlayer::NUmTurns;

同时旧式编译器也许不支持上述语法，不允许static成员在其声明式上获得初值。（此外in-class初值设定，也只允许对整数常量进行）则可将初值放入定义式中：

class CostEstimate{
private:
     static const double FudgeFactor;//static class 常量声明
     ...//位于头文件内
};
const double CostEstimate::FudgeFactor=1.35;//static class常量定义，位于实现文件内

当在class编译期间需要class常量值时，可以改用“the enum hack”补偿做法，其理论基础是“一个属于枚举类型（enumerated type）的数值可权充ints被使用：

class gamePlayer{
private:
      enum{NumTurns=5};
      int  scores[NumTurns];
      ...
}; 

请注意，我们无法利用#define创建一个class专属常量。

以及enum hack与#define更相似，获取一个const地址是合法的,而获取enum和#define的地址不合法。但是enum和#define不会导致非必要的内存分配。

最后就是，使用template inline函数的宏可以带来更大的效率：

template <typename T>
inline void callWithMax(const T&a,const T&b)
{
       f(a>b?a:b);
}

有了consts、enums、inlines，我们对预处理器（#define）的需求降低了，但#include仍是必须品，而#ifdef/#ifndef也继续扮演控制编译的角色。

~对于单纯常量，最好以const对象或enums替换#define

~对于形似函数的宏（macros），最好改用inline替换#define

条款03：尽可能使用const

const:允许你指定一个语义约束（一个“不该被改动”的对象），编译器会强制实施者项约束。

在指针中，const出现在*左边，表示被指物是常量；出现在*右边，表示指针自身是常量。

void f1(const Widget* pw);//f1、f2是相同的
void f2(Widget const *pw);

STL迭代器，const声明表示，迭代器不得指向不同的东西，但所指的东西可以改变，如果希望他无法改变，就需要使用const_iterator：

std::vector<int> vec;
...
const std::vector<int>::iterator iter=vec.begin();
*iter=10;//没问题，改变的是iter所指之物
++iter;//错误，iter是const
std::vector<int>::const_iterator cIter=vec.begin();
*cIter=10;//错误，*cIter是const
++cIter;//没错，改变cIter

函数返回一个const值，可以防止其被客户改动：

class Rational{...};
const Tarional operator* (const Rational& lhs,const Tarional& rhs);

const函数内调用non-const函数，就改动了曾经做的承诺。所以我们必须使用const_cast将*this身上的const解放掉。

const operator[]完全做掉了non-const版本该做的一切，这种情况可以将const转除：

class Textblock{
public:
...
const char& operator[](std::size_t position)const
{
...
return text[position];
}
char& operator[](std::size_t position)//调用const op[]
{
return 
   const _cast<char&>(//将op[]返回值的const转除
      static_cast<const TextBlock&>(*this)[position]//为*this加上const,调用const op[]
      );
}
...
};

为了避免operator[]递归调用自己，我们必须明确指出调用的是const operator[]，所以这里将*this从原始类型TextBlock&转型为const TextBlock&。

这里共有两次转型1.*this 添加const

2.const operator[]返回值中移除const

条款04：确定对象被使用前已先被初始化

通常使用C part of C++而且初始化可能招致运行期成本，那么久不保证发生初始化。一旦进入non-C parts of C++规则就有变化。这就好解释为什么array不保证其内容被初始化，而vector却需要保证。

最佳出来办法就是：永远在使用对象之前将他初始化。

int x=0;//初始化int
const char* text="A C-style string";//初始化指针
double d;
std::cin>>d;//以读取input stream的方式初始化

至于内置类型以外的东西，初始化责任在构造函数上，规则很简单：保证每一个构造函数都将对象的每一个成员初始化。

class PhoneNumber{...}
class ABEntry{
public:
     ABEntry(const std::string& name,const std::string& address,const std::list<PhoneNumber>&phone);
private:
   std::string theName;
   std::string theAddress;
   std::list<PhoneNumber> thePhones;
   int numTinesConsulted;
};

ABEntry::ABEntry(cosnt std::string& name,const std::string& address,const std::list<PhoneNumber>&phones)
{//赋值
     theName=name;
     theAddress=address;
     thePhones=phones;
     numTimesConsulted=0;
}

ABEntry::ABEntry(cosnt std::string& name,const std::string& address,const std::list<PhoneNumber>&phones)
://初始化
     theName(name);
     theAddress(address);
     thePhones(phones);
     numTimesConsulted(0);
{  }

不使用初始化而赋值，会使得成员对象在初始化发生时间更早，发生于这些default构造函数被调用之前，是的资源浪费。

ABEntry::ABEntry()//成员初值表
     :theName(),
      theAddress(),
      thePhones(),
      numTimesConsulted(0)
{}

规定总是在初值列中列出所有成员变量，以免还得记住那些成员变量可以无需初值。

当许多classes拥有多个构造函数时，每个构造函数都会有自己的成员初值列，就会导致很对重复的工作，这种情况下，可以合理的在初值列遗漏那些“赋值表现好的成员”，对他们改用赋值。

C++，有着十分固定的“成员初始化次序”（不会报错），base classes(基类）先于derived classes（派生类)。

在，问题涉及多个源码文件时，会发生使用某一non-local static对象的初始化使用了另一编译单元内的某个non-local static对象，他有可能尚未被初始化。

这时我们需要做的便是：将每个non-local static对象搬到自己的专属函数中（该对象在此函数内被声明为static)。喊句话说，non-local static 被local static替换了。

例：

class FileSystem{//来着你的程序库
public:
     ...
    std::size_t numDisks()const;//成员函数
     ...
};
extern Fileststem tfs;//预备给客户使用的对象

class Directory{//由程序库客户建立
public:
    directory(params);
    ...
};
Directory::Directory(params)
{
    ...
    std::size_t disks=tfs.numDisks();//使用tfs对象
    ...
}
Directory tempDir(params);//为临时文件做目录

除非tfs在tempDir之前初始化，否则tempDir会使用尚未出生的tfs。

改动：

class FileStstem{...}
FileSystem& tfs()//替换tfs对象
{//FileSystem class 中可能是个static.
    static FileSystem fs;//定义初始化一个local static对象
    return fs;//返回一个reference上述对象
}
class Directory{...};
Directory::Directory(params)
{
    ...
    std::size_t disks=tfs.numDisks();//使用tfs对象
    ...
}
Dierctory& tempDir()//替换tempDir对象
{
     static Directory td;
     return td;
}

~为内置型对象手工初始化，C++ 不保证他们初始化。

~构造函数最好使用成员初值列，而不要再构造函数本体内使用赋值。

~为免除"跨编译单元的初始化次序"问题，用local static对象替换non-local static。