C++ 模式设计

只写了MinGw/Linux API部分。所有相关的代码都是参考C++ API

C++ 11智能指针参考http://blog.csdn.net/zy19940906/article/details/50470087

<1>Pimpl

pointer to the implementation

计算一个累构造消耗的时间。

AutoTimer.h

//
// Created by Administrator on 2017/3/26.
//

#ifndef MODERN_DESIGN_AUTOTIMER_H
#define MODERN_DESIGN_AUTOTIMER_H
#include <iostream>
#include <string>
#include <memory>
class AutoTimer
{
public:
    explicit AutoTimer(const std::string &name);
    ~AutoTimer();
private:
    class Impl;
    Impl *_mimpl;
    // std::unique_ptr <Impl> _mimpl; //智能指针,生命周期与类成员周期相同
};

#endif //MODERN_DESIGN_AUTOTIMER_H

AutoTimer.cpp

#include "AutoTimer.h"
#include <sys/time.h>
class AutoTimer::Impl
{
public:
    double getElapsed() const
    {
        timeval end_time;
        gettimeofday(&end_time,NULL);
        double t1 = _start_time.tv_usec / 1e6 + _start_time.tv_sec;
        double t2 = end_time.tv_usec / 1e6 + end_time.tv_sec;
        return t2 - t1;
    }
    std::string _name;
    timeval _start_time;
};
AutoTimer::AutoTimer(const std::string &name):_mimpl(new AutoTimer::Impl())
{
    _mimpl->_name = name;
    gettimeofday(&_mimpl->_start_time,NULL);
}
AutoTimer::~AutoTimer()
{
    std::cout << _mimpl->_name << ":took " << _mimpl->getElapsed() << " secs" <<std::endl;
    delete _mimpl; // 如果是智能指针不需用
    _mimpl= NULL;  // 如果是智能指针不需用
}

main.cpp:

AutoTimer timer("Houdini");
AutoTimer timer2("Maya");

输出:

Maya:took 0.000999928 secs
Houdini:took 0.000999928 secs

C语言的不透明指针。。。。实现就是这么轻松随意。。。。

AutoTimer.h

#ifndef MODER_DESIGN_C_AUTOTIMER_H
#define MODER_DESIGN_C_AUTOTIMER_H
// 声明一个指向AutoTimer结构体不透明的指针
typedef struct AutoTimer *AutoTimerPtr;
AutoTimerPtr AutoTimerCreate(const char *name);
void AutoTimerDestroy(AutoTimerPtr ptr);

#endif //MODER_DESIGN_C_AUTOTIMER_H

AutoTimer.cc

#include "AutoTimer.h"
#include <sys/time.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

struct AutoTimer
{
    char *mName;
    timeval mStartTime;
};

AutoTimerPtr AutoTimerCreate(const char *name)
{
    AutoTimerPtr ptr = static_cast<AutoTimerPtr> (malloc(sizeof(AutoTimer))); // 因为我们用的是C++编译器，所以还是显式转换
    if(ptr)
    {
        ptr->mName = strdup(name);
        gettimeofday(&ptr->mStartTime,NULL);
    }
    return ptr;
}
static double GetElapsed(AutoTimerPtr ptr)
{
    timeval end_time;
    gettimeofday(&end_time,NULL);
    double t1 = ptr->mStartTime.tv_usec / 1e6 + ptr->mStartTime.tv_sec;
    double t2 = end_time.tv_usec / 1e6 + end_time.tv_sec;
    return t2-t1;
}
void AutoTimerDestroy(AutoTimerPtr ptr)
{
    if(ptr)
    {
        printf("%s took %f secs\n",ptr->mName,GetElapsed(ptr));
        free(ptr);
    }
}

main.cpp

AutoTimerPtr ptr = AutoTimerCreate("Houdini");
AutoTimerDestroy(ptr);

AutoTimerPtr ptr2 = AutoTimerCreate("Maya");
AutoTimerDestroy(ptr2);

输出:

Houdini took 0.000000 secs
Maya took 0.000000 secs
Hello, World!

<2> 单例模式:

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;

class Singleton
{
public:

    static Singleton &GetInstance()
    {
        static Singleton *instance  = NULL;
        if(! instance)
        {
            std::mutex mutex;
            if(! instance)
            {
                instance = new Singleton();
            }
            mutex.unlock();
        }
        return *instance;
    }
    static Singleton *GetInstancev2()
    {
        static Singleton m_instance;
        return &m_instance;
    }

private:
    Singleton()
    {

    }
    ~Singleton()
    {

    }
    Singleton(const Singleton &);
    const Singleton &operator=(const Singleton &);

};

void threadFunc(string name,int uniqueId)
{
    std::cout << "Singleton meomery:" << name << " -> " << uniqueId << " :Object &"<<&Singleton::GetInstance() <<"\n";
}
void threadRun()
{
    thread thread_01(threadFunc,"houdini",);
    thread thread_02(threadFunc,"maya",);
    thread thread_03(threadFunc,"blender",);

    thread_01.join();
    thread_02.join();
    thread_03.join();

}

int main()
{
    Singleton &obj = Singleton::GetInstance();
    std::cout << &obj <<std::endl;
    //
    std::cout << "test in thread \n";
    threadRun();

    // test use another
    std::cout << "GetInstancev2 method create \n";
    Singleton *obj2 = Singleton::GetInstancev2();
    std::cout << obj2 <<std::endl;

    Singleton *obj3 = Singleton::GetInstancev2();
    std::cout << obj3 << std::endl;
    return ;
}

输出:

0x3e67c0
test in thread
Singleton meomery:Singleton meomery:blender -> Singleton meomery:maya -> houdini -> 0 :Object &0x3e67c0
1 :Object &0x3e67c0
2 :Object &0x3e67c0
GetInstancev2 method create
0x4060b0
0x4060b0

<3> 工厂模式

<4> 写时复制，节省内存最好的方法就是确实需要时再分配。所有客户共享一份唯一的资源，直到其中一个想修改这份资源为止，只有在哪个时间点才回构造副本.

template <class T> class CowPtr
{
public:
    using RefPtr = std::shared_ptr<T> ;
    inline CowPtr():mPtr(){}
    inline CowPtr(const CowPtr<T> &other):mPtr(other.mPtr)
    {
        std::cout << "copy function "<< __LINE__<< "\n";
    }
    inline explicit CowPtr(T *other):mPtr(other){}
    inline T &operator*()
    {
        std::cout<< "inline T &operator*()" <<__LINE__<<std::endl;
        Detach();
        return *(mPtr.get());
    }
    inline const T &operator*() const {
        std::cout<< "inline const T &operator*() const" <<__LINE__<<std::endl;
        return *(mPtr.get());
    }
    inline T*operator->()
    {
        std::cout<< "inline T*operator->()" <<__LINE__<<std::endl;
        Detach();
        return mPtr.get();
    }
    inline const T*operator->() const {
        std::cout<< "inline const T*operator->() " << __LINE__<<std::endl;
        return mPtr.get();
    }

    inline const T*data()const
    {
        std::cout<< "inline const T*data()const " << __LINE__<<std::endl;
        return mPtr.get();
    }

    inline bool operator==(const CowPtr<T> &other) const {
        return mPtr.get() == other.mPtr.get();
    }

    inline bool operator!() const
    {
        return !mPtr.get();
    }
    inline CowPtr &operator=(T *other)
    {
        mPtr = RefPtr(other);
        return *this;
    }

private:
    inline void Detach()
    {
        T *temp = mPtr.get();
        if(temp && !mPtr.unique())
        {
            mPtr = RefPtr(new T(*temp)); //
        }
    }
    RefPtr  mPtr;

};

class WriteOnCopy
{
public:
    WriteOnCopy(){}
    std::string getValue() const
    {
        return *mData;

    }
    void setValue(const std::string &value)
    {
        mData = new std::string(value);
    }

private:
    CowPtr<std::string> mData;
};

int main()
{
    CowPtr<std::string> string1(new std::string("houdini"));
    CowPtr<std::string> string2(string1);  //copy function
    CowPtr<std::string> string3(string1);  //copy function
    string3->append("!!");
    std::cout  << *string3.data()<<std::endl;  //houdini!!
    std::cout  << *string1<<std::endl; // houdini

    std::cout << "\n after change 1 \n";
    CowPtr<std::string> pr_string1(new std::string("share me"));
    char &char_ref = pr_string1->operator[](); //use the string operator[] function
    CowPtr<std::string> pr_string2(pr_string1);
    char_ref = 'H'; // after change 'H'
    std::cout  << *(pr_string1.data())<<std::endl;  //sHare me
    std::cout  << *(pr_string2.data())<<std::endl;  //sHare me

    // use write on copy
    std::cout << "\nwrite on copy\n";
    WriteOnCopy obj1;
    obj1.setValue("hello");
    WriteOnCopy obj2 = obj1;
    std::string val = obj2.getValue();
    WriteOnCopy obj3 = obj1;
    obj3.setValue("There");
    std::cout << "obj1 get data " << obj1.getValue() <<std::endl;
    std::cout << "obj2 get data " << obj2.getValue() <<std::endl;
    std::cout << "obj3 get data " << obj3.getValue() <<std::endl;

    return ;
}

<5>CPP Style

(1)更好的重载operator

GLY_Currency.h

#ifndef CPPSTYLE_GLY_CURRENCY_H
#define CPPSTYLE_GLY_CURRENCY_H

#include <memory>
#include <iostream>
class GLY_Currency
{
public:
    explicit GLY_Currency(int value);
    ~GLY_Currency();
    GLY_Currency(const GLY_Currency&obj);
    int getValue()const;

// these operators must be declared as member functions
    GLY_Currency &operator =  (const GLY_Currency &rhs);
    GLY_Currency &operator += (const GLY_Currency &rhs);
    GLY_Currency &operator -= (const GLY_Currency &rhs);
    GLY_Currency &operator *= (const GLY_Currency &rhs);
    GLY_Currency &operator /= (const GLY_Currency &rhs);

private:
    class Impl;
    std::unique_ptr <Impl> mImpl;
};

// these operators can (and should) be declared as free functions
inline GLY_Currency operator+(const GLY_Currency &lhs,const GLY_Currency &rhs)
{
    // 复制一份是因为lhs+=rhs 会导致 lhs更改数据，因为lhs是const,所以不用复制构造，会导致
    // 编译错误
    return GLY_Currency(lhs)+=rhs;
}
inline GLY_Currency operator-(const GLY_Currency &lhs ,const GLY_Currency &rhs)
{
    return GLY_Currency(lhs)-=rhs;
}
inline GLY_Currency operator*(const GLY_Currency &lhs ,const GLY_Currency &rhs)
{
    return GLY_Currency(lhs)*=rhs;
}
GLY_Currency operator /(const GLY_Currency &lhs, const GLY_Currency &rhs)
{
    return GLY_Currency(lhs) /= rhs;
}

inline bool operator==(const GLY_Currency &lhs,const GLY_Currency &rhs)
{
    return lhs.getValue()==rhs.getValue();
}

inline bool operator!=(const GLY_Currency &lhs,const GLY_Currency &rhs)
{
    return !(lhs==rhs);
}
inline bool operator<(const GLY_Currency &lhs,const GLY_Currency &rhs)
{
    return rhs.getValue()<rhs.getValue();
}
inline bool operator>(const GLY_Currency &lhs,const GLY_Currency &rhs)
{
    return rhs < lhs;
}

inline bool operator<=(const GLY_Currency &lhs,const GLY_Currency &rhs)
{
    return !(rhs > rhs);
}
inline bool operator>=(const GLY_Currency &lhs,const GLY_Currency &rhs)
{
    return rhs <= lhs;
}

inline std::ostream &operator <<(std::ostream &os,const GLY_Currency &rhs)
{
    os << rhs.getValue();
    return os;
}

#endif //CPPSTYLE_GLY_CURRENCY_H

GLY_Currency.cpp

//
// Created by Administrator on 2017/5/2.
//

#include "GLY_Currency.h"
class GLY_Currency::Impl
{
public:
    int mValue;
};

GLY_Currency::GLY_Currency(int value):mImpl(new Impl)
{
    mImpl->mValue = value;
}
GLY_Currency::~GLY_Currency() {

}

GLY_Currency::GLY_Currency(const GLY_Currency &obj):mImpl(new Impl)
{
    mImpl->mValue = obj.mImpl->mValue;
}
int GLY_Currency::getValue() const {
    return mImpl->mValue;
}

GLY_Currency& GLY_Currency::operator=(const GLY_Currency &rhs) {
    if (this != &rhs)
    {
        mImpl->mValue = rhs.mImpl->mValue;
    }
    return *this;
}
GLY_Currency& GLY_Currency::operator-=(const GLY_Currency &rhs) {
    mImpl->mValue -= rhs.mImpl->mValue;
    return *this;
}
GLY_Currency& GLY_Currency::operator+=(const GLY_Currency &rhs) {
    mImpl->mValue += rhs.mImpl->mValue;
    return *this;
}

GLY_Currency& GLY_Currency::operator*=(const GLY_Currency &rhs) {
    mImpl->mValue *= rhs.mImpl->mValue;
    return *this;
}
GLY_Currency& GLY_Currency::operator/=(const GLY_Currency &rhs) {
    mImpl->mValue /= rhs.mImpl->mValue;
    return *this;
}

<6>Exception Basic

#include <iostream>

/*
// BASIC
template <typename T>
T safe_divide(T const&a,T const &b)
{
    if (b == 0)
    {
        const char *error = "b is zero do not allowed ";
        throw error;
    }
    return a/b;
}

int main()
{
    double result = 0.0 ;
    try
    {
        result = safe_divide(2.0,0.0);
    }
    catch (const char*s)
    {
        std::cout << s <<std::endl; // will get const char *error = "b is zero do not allowed "

        //try to use right arg
        result = safe_divide(2.0,1.0);
    }

    std::cout << result <<std::endl;
    return 0;
}*/

// Use class handle the error
class ClassBad_divide_Except
{
private:
    double v1;
    double v2;
public:
    ClassBad_divide_Except(double a=0.0,double b=0.0):v1(a),v2(b){

    }
    void mesg()
    {
        const char* mesgs = "Error divide argments :";
        std::cout <<mesgs << v1<<"/"<<v2<<std::endl;
    }
};

template <typename T>
T safe_divide(T const&a,T const &b)
{
    if (b == )
    {
        const char *error = "b is zero do not allowed ";
        throw ClassBad_divide_Except(a,b); //emit a class instance ClassBad_divide_Except()
    }
    return a/b;
}

int main()
{
    double result = 0.0 ;
    try
    {
        result = safe_divide(2.0,0.0);
    }
    catch (ClassBad_divide_Except &did) // get class ref
    {
        did.mesg(); // get error message

        //try to use right arg
        result = safe_divide(2.0,1.0);
    }

    std::cout << result <<std::endl;
    return ;
}

<7> RTTI

RTTI just compatable for a class have a virtual method