[C++]单例模式应用

单例模式的应用

单例模式：

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

class CSingleton
{
private:
    CSingleton() //构造函数是私有的
    {
    }
public:
    static CSingleton * GetInstance()
    {
        static CSingleton *m_pInstance;
        if(m_pInstance == NULL) //判断是否第一次调用
            m_pInstance = new CSingleton();
        return m_pInstance;
    }
};

具体应用：

测试文件：

#include "JobManager.h"
using namespace std;

int main() {
    JobManager *manager1 = JobManager::getInstance();
    JobManager *manager2 = JobManager::getInstance();
    int pris[5] = {234, 23, 23432, 1, 5};
    for (int i = 0; i < 5; i++) {
        manager1->addJob(pris[i]);
    }
    manager2->printJob();
    cout << "The number of job is: " << manager1->getNumOfJob() << endl;
    manager1->finishOneJob();
    cout << "The number of job is: " << manager1->getNumOfJob() << endl;
    manager2->finishOneJob();
    cout << "The number of job is: " << manager1->getNumOfJob() << endl;
    manager1->addJob();
    manager1->addJob(6666);
    manager1->printJob();
    cout << "The number of job is: " << manager1->getNumOfJob() << endl;
    manager2->clear();
    manager1->printJob();
    cout << "The number of job is: " << manager1->getNumOfJob() << endl;

    int jobNum, jobPriority, deleteNum;
    cin >> jobNum;
    for (int i = 0; i < jobNum; i++) {
        cin >> jobPriority;
        manager2->addJob(jobPriority);
    }
    manager1->sortJob();
    manager2->printJob();
    cin >> deleteNum;
    while (deleteNum--) {
        manager1->finishOneJob();
    }
    manager1->printJob();
    cout << "The number of job is: " << manager2->getNumOfJob() << endl;

    if (JobManager::deleteInstance()) cout << "Delete successfully!\n";
    else cout << "Delete failure!\n";

    if (JobManager::deleteInstance()) cout << "Delete successfully!\n";
    else cout << "Delete failure!\n";
}

实现文件1：

此处是把job用list实现。

/*
 * declaration for class Job..
 */
#ifndef JOB_H

#include<string>
using namespace std;

class Job {
public:
    explicit Job(int priority = 0);
    void setId(int id);
    int getId() const;
    void setPriority(int priority);
    int getPriority() const;
    void setNext(Job *job);
    Job *getNext() const;
    string toString();
private:
    static int number;
    int id;
    int priority;
    Job* nextJob;
};

#endif

#include "Job.h"
#include <sstream>
int Job::number = 0;
Job::Job(int _priority) {
    priority = _priority;
    nextJob = NULL;
    id = number;
    number++;
}
void Job::setId(int _id) {
    id = _id;
}
int Job::getId() const {
    return id;
}
void Job::setPriority(int priority_) {
    priority = priority_;
}
int Job::getPriority() const {
    return priority;
}
void Job::setNext(Job *jobs) {
    this->nextJob = jobs;
}
Job* Job::getNext() const {
    if (this->nextJob == NULL) {
        return NULL;
    }
    return nextJob;
}
inline std::string getstring(int onepart) {
    std::stringstream oneparts;
    oneparts << onepart;
    return oneparts.str();
}
std::string Job::toString() {
    // [id:priority]
    std::string answer = "[" + getstring(id) + ":"
        + getstring(priority) + "]";
    return answer;
}

实现文件2：

#ifndef JOBMANAGER_H
#define JOBMANAGER_H

#include <iostream>
#include "Job.h"

// disallow copy constructor and assignment operator
#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
TypeName(const TypeName&);               \
void operator=(const TypeName&)

class JobManager {
public:
    // get the unique instance
    static JobManager* getInstance();
    static bool deleteInstance();

    void addJob(int priority = 0);
    void finishOneJob();
    void sortJob();
    void printJob();
    int getNumOfJob();
    void clear();

private:
    Job * jobFrontPointer;
    ~JobManager();
    JobManager();
    static JobManager* instance;
    DISALLOW_COPY_AND_ASSIGN(JobManager);
};

#endif

#include "JobManager.h"
JobManager* JobManager::getInstance() {
    if (instance == 0) {
        instance = new JobManager();
    }
    return instance;
}
bool JobManager::deleteInstance() {
    if (instance == NULL) {
        return false;
    } else {
        delete instance;
        instance = NULL;
        return true;
    }
}

void JobManager::addJob(int priority) {
    if (getNumOfJob() == 0) {
        jobFrontPointer = new Job(priority);
    } else {
        int i = 1;
        Job* temp = jobFrontPointer;
        while (i != getNumOfJob()) {
            temp = temp->getNext();
            i++;
        }
        Job *anotherOne = new Job(priority);
        temp->setNext(anotherOne);
    }
}

void JobManager::finishOneJob() {
    if (getNumOfJob() == 0) {
        return;
    } else {
        Job* temp = jobFrontPointer;
        jobFrontPointer = jobFrontPointer->getNext();
        delete temp;
    }
}
void JobManager::sortJob() {
    if (jobFrontPointer != NULL && jobFrontPointer->getNext() != NULL) {
        Job* slow = jobFrontPointer;
        Job* fast = jobFrontPointer->getNext();
        while (fast != NULL) {
            if (fast->getPriority() < slow->getPriority()) {
                fast = fast->getNext();
                slow = slow->getNext();
            } else {
                Job* pre = jobFrontPointer;
                if (jobFrontPointer->getPriority() < fast->getPriority()) {
                    slow->setNext(fast->getNext());
                    fast->setNext(jobFrontPointer);
                    jobFrontPointer = fast;
                } else {
                    while (pre->getNext()->getPriority()
                           >= fast->getPriority()) {
                        pre = pre->getNext();
                    }
                    slow->setNext(fast->getNext());
                    fast->setNext(pre->getNext());
                    pre->setNext(fast);
                }
                fast = slow->getNext();
            }
        }
    }
}
void JobManager::printJob() {
    if (getNumOfJob() == 0) {
        cout << "empty!" << endl;
        return;
    }
    cout << jobFrontPointer->toString();
    for (Job* temp = jobFrontPointer->getNext();
         temp != NULL; temp = temp->getNext()) {
        cout << "->" << temp->toString();
    }
    cout << endl;
}
int JobManager::getNumOfJob() {
    int totalNumber = 0;
    Job* temp = jobFrontPointer;
    while (temp != NULL) {
        totalNumber++;
        temp = temp->getNext();
    }
    return totalNumber;
}
void JobManager::clear() {
    Job* temp = jobFrontPointer;
    while (temp != NULL) {
        Job* temp1 = temp;
        temp = temp->getNext();
        temp1->setNext(NULL);
        delete temp1;
    }
    jobFrontPointer = NULL;
}

// private :
JobManager* JobManager::instance = NULL;
JobManager::~JobManager() {
    clear();
}
JobManager::JobManager() {
    jobFrontPointer = NULL;
}

每次做list的时候都要注意最后是否存在memory leak.

sort函数的另一种偷懒做法。

void JobManager::sortJob() {
    // if no or one item in queue, no need to sort it..
    if (jobFrontPointer == NULL || jobFrontPointer->getNext() == NULL) return;

    int nums = getNumOfJob(), i = 0;
    Job *array[nums];
    Job *flagPointer = jobFrontPointer;
    // store each job in array..
    while (flagPointer != NULL) {
        array[i++] = flagPointer;
        flagPointer = flagPointer->getNext();
    }
    // sort each job..
    sort(array, array + nums, cmp);

    array[nums - 1]->setNext(NULL);

    jobFrontPointer = array[0];
    flagPointer = jobFrontPointer;
    for (i = 1; i < nums; i++) {
        flagPointer->setNext(array[i]);
        flagPointer = flagPointer->getNext();
    }
}