单例模式理解附log4cpp.cc

单例模式：通过一个类只能创建一个对象

例class singleton{

public:

static singleton *get _sigleton(){//这里需要添加static 修饰符 如果不添加 singlet函数只能通过对象调用　我们希望在没有对象的情况下　也能调用该函数　所以添加static

if(NULL ==_pintsance){

_psingalton = new singleton;

}

return singalton;／／但是内仅只有new　是不行的　因我们需要能够判断　是否只有一个对象　我们希望每一次调用geti_instance() 时 操作的都是第一次创建的对象 当然返回的也是第一次创建的对象 

}

private:

singleton(){};

~singleton(){};

static singleton * _pinstance //static 函数只能操纵static 成员变量

}

int main(){

singleton s1;//我们不希望这样的情况出现 即我们不希望创建栈对象SO 我们需要将 构造函数放在private

}

演化步骤：

1.为了避免创建栈对象 将构造函数私有化

2.创建一个成员函数signalton * get_instance()用来创建堆对象

3.private里定义一个指针 _pinstance接受 创建的堆对象

4.为了保证 在没有对象的时候 能够创建第一个对象  要用static 修饰 singalton *get_instance()函数

5.static函数只能调用 static变量 我们用static 修饰 _pinstance

6.为了让get_instance能够检测出 对象有没有被调用 我们将 _pinstance 初始化为null singalton *  singalton::_pinstance = NULL; 并在get_instance()中添加判断

///

/// @file    Mylog.h

/// @author  lemon([e-mail])

/// @date    2017-06-12 09:56:01

///

#ifndef __WD_MYLOG_H__

#define __WD_MYLOG_H__

#include <sstream>

#include <string>

using std::string;

//尽量减少头文件的依赖

#include <log4cpp/Category.hh>

using namespace log4cpp;

class Mylog

{

public:

static Mylog * getInstance();

static void destroy();

void error(const char * msg);

void warn(const char * msg);

void info(const char * msg);

void debug(const char * msg);

private:

Mylog();//将构造函数和析构函数放在类内

~Mylog();

private:

static Mylog * _pInstance;

Category & _cat;

};

inline string int2str(int number)

{

std::ostringstream oss;

oss << number;

return oss.str();

}

#define prefix(msg) string(" [ ").append(__FILE__).append(":")\

.append(__func__).append(":")\

.append(int2str(__LINE__)).append(" ] ")\

.append(msg).c_str()

void logError(const char * msg);

void logWarn(const char * msg);

void logInfo(const char * msg);

void logDebug(const char * msg);

#define LogError(msg) logError(prefix(msg))

#define LogWarn(msg) logWarn(prefix(msg))

#define LogInfo(msg) logInfo(prefix(msg))

#define LogDebug(msg) logDebug(prefix(msg))

#endif

///

/// @file    Mylog.cc

/// @author  lemon([e-mail])

/// @date    2017-06-12 10:01:33

///

//在实现文件中，第一个头文件一定是与该实现分开的这一头文件

#include "Mylog.h"

#include <log4cpp/PatternLayout.hh>

#include <log4cpp/OstreamAppender.hh>

#include <log4cpp/FileAppender.hh>

#include <log4cpp/Priority.hh>

#include <iostream>

using std::cout;

using std::endl;

Mylog * Mylog::_pInstance = NULL;

Mylog * Mylog::getInstance(){

if(NULL == _pInstance)

_pInstance = new Mylog();

return _pInstance;

}

void Mylog::destroy(){

if(_pInstance){

delete _pInstance;

}

}

Mylog::Mylog()

: _cat(Category::getRoot().getInstance("debugCat")){

PatternLayout * ptnLy1 = new PatternLayout();

ptnLy1->setConversionPattern("%d: %p %c:%m%n");

PatternLayout * ptnLy2 = new PatternLayout();

ptnLy2->setConversionPattern("%d: %p %c:%m%n");

OstreamAppender * pOs = new OstreamAppender("pOs", &cout);

pOs->setLayout(ptnLy1);

FileAppender * pFileApd = new FileAppender("pFileApd", "wd.log");

pFileApd->setLayout(ptnLy2);

_cat.addAppender(pOs);

_cat.addAppender(pFileApd);

_cat.setPriority(Priority::DEBUG);

cout << "Mylog()" << endl;

}

Mylog::~Mylog(){

Category::shutdown();

cout << "~Mylog()" << endl;

}

void Mylog::error(const char * msg){

_cat.error(msg);

}

void Mylog::warn(const char * msg){

_cat.warn(msg);

}

void Mylog::info(const char * msg){

_cat.info(msg);

}

void Mylog::debug(const char * msg){

_cat.debug(msg);

}

void logError(const char * msg){

Mylog::getInstance()->error(msg);

}

void logWarn(const char * msg){

Mylog::getInstance()->warn(msg);

}

void logInfo(const char * msg){

Mylog::getInstance()->info(msg);

}

void logDebug(const char * msg){

Mylog::getInstance()->debug(msg);

}