Effective C++ 学习笔记 (1)

最新推荐文章于 2024-11-14 21:19:37 发布

jianghuyue

最新推荐文章于 2024-11-14 21:19:37 发布

阅读量382

点赞数

文章标签： c++ iostream class preprocessor exception construction

本文链接：https://blog.csdn.net/jianghuyue/article/details/2979901

版权

Effective C++ 学习一从c语言世界来到C++世界~~

Item1 优先使用const 和inline来取代#define

这个准则应该理解成优先依靠compiler而不是依靠preprocessor来检查程序的错误。

定义一个常量的格式 const int NUM_LIMIT = 100;

1 当定义常量指针的时候，事情略微变得复杂

const char * pConst const = "is a constant pointer points to const";

2 定义一个类的常量成员变得简单。

class GamePlayer{

private :

static const int NUM_TURNS = 5;//注意这里的NUM_TURNS仅是个变量的声明

int scores[NUM_TURNS];

};

在函数的实现部分加入NUM_TURNS 的定义，这是必须，否则linker在link stage会提示出错。

const int GamePlayer::NUM_TURNS;

3 在你需要在class A编译阶段使用class A constant时候

如

class GamePlayer {

private:

enum {NUM_TURNS = 5};

int scores[NUM_TURNS];

......

}

#define max(a, b) ((a) > (b) ? (a) : (b))

宏定义一些简单常用函数，可以减少调用函数的开销，它同时has many drawbacks，

int a = 5, b = 10;

max(++a, b);

max(++a, b+10);

看看会有什么奇怪的事情发生

用inline来代替macro define定义。

inline int max(int a, int b) { return a > b ? a : b; }

更近一步使用,使用Generic programming：

template<class T>

inline const T& max(const T& a, const T& b) {return a > b ? a : b;}

Item 2 优先使用iostream 而不是stdio.h。

1 iostream提供了更好的扩展性和类型安全的。

iostream是将std命名空间的成员引入程序，而iostream.h将global namespace中的成员引入，这样可能会导致namespace 污染。

Item 7 准备好内存溢出情况发生后如何处理

当使用new操作符分配堆内存的时候，如果可用内村用光，则会抛出bad_alloc 异常。 bad_alloc异常是有operator new导致的异常，他在内存请求不能被满足的时候（内存用光）被抛出。

按照c风格，你可能定义一个宏来处理out of memory异常，如

#define NEW (PTR, TYPE) try {PTR=new TYPE;} catch (std::bad_alloc&) {assert(0);}

ps: 其中assert是一个宏其对应的h文件为c <assert.h>和c++ <cassert> 该宏检查传递给它的表达式是否是非零，如果是零，则返回一个出错信息并且调用abort中止程序执行。

但是这样就够了吗？答案是不够。因为它忽略了new的多种分配内存空间的方法，可以想到的是

new TYPE; new TYPE(construction parameters)； new TYPE[buffer_length]

还有更加复杂的情况，因为在C++中，用户可以自己定义其operator new的行为，这样算来，可能的情况何止区区3，4种。所以这种方式不能满足我们的需求。

那应该怎么做呢？

答案是通过定义自己的out of memory handler函数来处理out of memory异常。调用set_new_handler【在<new>头文件中定义】

set_new_handler的声明大概是这个样子：

typedef void (*new_handler)();

new_handler set_new_handler(new_handler p) throw();

set_new_handler的使用方式如下：

定义你自己的handler函数，然后装载到Global namespace当中去。

void noMoreMemory() {

cerr<< "Unable to satisfy the memory request.";

abort();

}

int main()

{

set_new_handler(noMoreMemory);

int * p = new int[10000000];

}

这样当请求内存不能被满足的时候，首先打印出错误信息，然后才会abort 程序。这样就比简单的core dump(清空寄存器，信息转存)要好的多。

可以装载新的handler就一样可以卸载handler，具体：

set_new_handler(null);

当operator new不能分配足够的内存时，它会重复执行调用handler function，直到内存请求可以被满足为止.

所以设计良好的handler函数应该可以完成以下动作中的一种：

1 分配更多内存或会使分配的内存以满足内存请求

2 安装不同的handler函数来处理该请求。如果当前的handler函数不能处理当前的请求，但是它知道其它的handler函数可以处理这个请求，所以它会装载另外一个handler函数。这样，在下次该请求不能被满足的时候，

新安装的handler function就会被调用来处理该请求。

3 卸载handler函数， set_new_handler(null)，这样在处理out of memory时将抛出异常bad_alloc.

4 Throw exception: 如果自定义exception，需要继承bad_alloc,使其形成类层次结构。

5 not return：默认行为是abort 或 exit.

对应于类来说：

class X {

public :

static new_handler set_new_handler(new_handler p);

static void * operator new (size_t size);

private:

static new_handler currentHandler;

}

new_handler X::currentHandler;

new_handler X::set_new_handler(new_handler p){

new_handler oldHandler = currentHandler;

currentHandler = p;

return oldHandler;

}

而对于X的operator new 的动作：

1 调用global的set_new_handler,来加载X的currentHandler

2 调用global的new操作， ::new 来进行内存分配。如果内存分配不能满足，global new operator将会调用X的handler，也就是刚被装载成为global 的handler，如果new最终都不能满足内存分配请求，它将抛出bad_alloc异常，会被捕获，同时会重新装载原来的global new-handler.并且重新抛出异常

3 如果分配请求成功 X的operator new会重新装载原来的global new handler.

在考虑一下， X的out of memory处理和X本身无关，可以使用继承和template来生成可以重用的代码。

template <class T>

class NewHandlerSupport {

public:

static new_handler set_new_handler (new_handler p);

static void* operator new (size_t size);

private :

static new_handler currentHandler;

}

template <class T>

new_handler NewHandlerSupport<T>::set_new_handler(new_handler p)