一個c++給程序打log的單例模式類

開發過程中需要給程序打log. 所以照着網上寫了個單例模式的log類

#ifndef MISCLOGWRITER_H_
#define MISCLOGWRITER_H_

#include <iostream>
#include <fstream>
#include <string>
#include <vector>

namespace miscfactory
{
class MiscLogWriter
{
    public:
        ~MiscLogWriter();
        //獲取本類的對象  
        static MiscLogWriter* getInstance();  
           
           //刪除本類的對象
           void del();

　　    //往log文件寫東西
        bool writeLog(const char* logInfo);
        bool writeLog(const std::string& logInfo);
        bool writeLog(std::vector<char*>& vectorLogInfo);
        bool writeLog(std::vector<std::string>& vectorLogInfo);
　　　　 //清空文件內容
        static bool clearFile();
        //重新設置文件路徑
        static bool setLogLocation(const char* logPath);

    private:
        MiscLogWriter();   //之所以把構造函數弄成私有是因為:不允許外界直接定義這個log類的對象,只能我這個類通過getInstance自己定義對象 32 　　　　 //打開log文件,關閉log文件
        static std::ofstream* openFile();
        static bool closeFile(std::ofstream* ofsHandle);

　　　　//指定的log文件所在的路徑是否合法
        static bool isAvailableLocation(const char* logPath);

        static std::string        m_filePath;   //log's 文件路徑
        static MiscLogWriter*    m_miscLogWriter; //本類的一個對象指針,getInstance總是返回這個對象的指針. 弄成靜態的是因為可以讓靜態函數getInstance直接返回
    };
}//namespace miscfactory

#endif /*MISCLOGWRITER_H_*/

 

#include "miscfactory/misclogwriter.h"
#include <string.h>
#include <iostream>
#include <fstream>

namespace miscfactory
{

using namespace std;

MiscLogWriter* MiscLogWriter::m_miscLogWriter = NULL;
std::string MiscLogWriter::m_filePath = string("./miscLog.log");   //靜態成員變量必須要初始化,而且初始化要放到cpp中不能放到.h中

MiscLogWriter::MiscLogWriter()
{

}

MiscLogWriter::~MiscLogWriter()
{
       /*//在析構函數中是否需要刪除靜態成員變量m_miscLogWriter指向的對象.或者說,這個析構函數到底會不會被執行.如果有這幾行,成員函數del執行時候,是否有沖突??

　　　　if (m_miscLogWriter != NULL)
       {
           if (m_miscLogWriter != NULL)     
           {
                delete m_miscLogWriter;
                m_miscLogWriter = NULL;
           }
       }
       */
}

    void MiscLogWriter::del() //單例模式下,把靜態成員變量所指向的對象的刪除工作放在析構函數中是不合適的吧,是否應該提供一個del函數,如果是,這個函數是否應該是靜態 ????
    {
        if (m_miscLogWriter != NULL)
         {
            delete m_miscLogWriter;
            m_miscLogWriter = NULL;
         }
    }

MiscLogWriter* MiscLogWriter::getInstance()
{
    if (m_miscLogWriter != NULL )
    {
        return m_miscLogWriter;
    }

    return m_miscLogWriter = new MiscLogWriter();
}

bool MiscLogWriter::setLogLocation(const char* logPath)
{
    if (!isAvailableLocation(logPath))
    {
        cout<<"logLocation ["<<logPath<<"] is unAvailable"<<endl;
        return false;
    }

    m_filePath = string(logPath);
    return true;
}

bool MiscLogWriter::isAvailableLocation(const char* logLocation)
{
    //TODO  check whether logLocation is a correct path
    return true;
}
bool MiscLogWriter::writeLog(const char* logInfo)
{
    ofstream* ofsHander = openFile();
    if (ofsHander == NULL)
    {
        cout<<"fileOpenError"<<endl;
        return false;
    }

    ofsHander->write( logInfo, strlen(logInfo) );
    ofsHander->write( "\n", strlen("\n") );
    closeFile(ofsHander);
    return true;
}

bool MiscLogWriter::writeLog(const string& logInfo)
{
    return writeLog(logInfo.data());
}

bool MiscLogWriter::writeLog(vector<char*>& vectorLogInfo)
{
    for (int i = 0; i < vectorLogInfo.size(); i++)
    {
        if (!writeLog(vectorLogInfo[i]))
        {
            return false;
        }
    }

    return true;
}

bool MiscLogWriter::writeLog(vector<string>& vectorLogInfo)
{
    for (int i = 0; i < vectorLogInfo.size(); i++)
    {
        if (!writeLog(vectorLogInfo[i].data()))
        {
            return false;
        }
    }

    return true;
}

ofstream* MiscLogWriter::openFile()
{
    if(!isAvailableLocation(m_filePath.data()))
    {
        return NULL;
    }

    ofstream* ofsHandle = new ofstream(m_filePath, ios::app); //追加方式打開文件
    return ofsHandle;
}

bool MiscLogWriter::closeFile(ofstream* ofsHandle)
{
    if (ofsHandle == NULL)
    {
        return true;
    }

    if (ofsHandle->is_open())
    {
        ofsHandle->close();
        delete ofsHandle;
        ofsHandle = NULL;
    }

    return true;
}

bool MiscLogWriter::clearFile()
{
    if(!isAvailableLocation(m_filePath.data()))
    {
        return false;
    }

    ofstream* ofsHandle = new ofstream(m_filePath, ios::out); //清空方式打開文件
    return closeFile(ofsHandle);
}
}//namespace miscfactory

調用

MiscLogWriter::setLogLocation("./miscLog.log");
MiscLogWriter::clearFile();

MiscLogWriter::getInstance().WriterLog("abc");

MiscLogWriter::getInstance().WriterLog("123");

MiscLogWriter::getInstance().del();