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

巴特西

C++ 模式设计

最新文章

热门文章