有时候需要定义全局变量供多个线程使用，为了对变量进行保护，需要对其进行加锁的操作

如果全局变量较多，每个变量都进行加锁的操作，会导致代码繁琐混乱

使用类模板，可以将加锁/解锁的操作统一

#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

template <class T>
class tepltTest
{
    public:
        tepltTest();
        ~tepltTest();

        bool operator == (const T& cmp);
        bool operator != (const T& cmp);
        bool operator !();
        void operator =(const T& val); 
        operator T();//overloaded type conversion operator 

    private:
        inline void Lock()
        {
            printf("Lock\n");
            pthread_mutex_lock(&m_mutex);
        }
        inline void Unlock()
        {
            printf("Unlock\n");
            pthread_mutex_unlock(&m_mutex);
        }
        inline void InitializeLock()
        {
            printf("InitializeLock\n");
            pthread_mutexattr_t mattr;
            pthread_mutexattr_init(&mattr);
            pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
            pthread_mutex_init(&m_mutex, &mattr);
            pthread_mutexattr_destroy(&mattr);
        }
        inline void DeInitializeLock()
        {
            printf("DeInitializeLock\n");
            pthread_mutex_destroy(&m_mutex);
        }


    private:
        T tepltT;
        pthread_mutex_t m_mutex;    
};

template <class T>
tepltTest<T>::tepltTest() 
{
    printf("tepltTest\n");
    InitializeLock();
}

template <class T>
tepltTest<T>::~tepltTest() 
{
    printf("~tepltTest\n");
    DeInitializeLock();
}

template <class T>
bool tepltTest<T>::operator == (const T& cmp)
{
    printf("operator ==\n");
    bool ret;
    Lock();
    ret = (tepltT == cmp);
    Unlock();
    return ret;
}

template <class T>
bool tepltTest<T>::operator != (const T& cmp)
{
    printf("operator !=\n");
    bool ret;
    Lock();
    ret = (tepltT != cmp);
    Unlock();
    return ret;
}

template <class T>
bool tepltTest<T>::operator ! ()
{
    printf("operator !\n");
    bool ret;
    Lock();
    ret = !tepltT;
    Unlock();
    return ret;
}

template <class T>
void tepltTest<T>::operator = (const T& val)
{
    printf("operator =\n");
    Lock();
    tepltT = val;
    Unlock();
}

template<class T>
tepltTest<T>::operator T() {//overloaded type conversion operator 
    printf("operator T\n");
    T bRet;
    Lock();
    bRet = tepltT;
    Unlock();
    return bRet;
}

int main()
{
    tepltTest<int> intType;
    intType = 10;
    int tt = intType; //call operator T
    printf("tt is %d\n",tt);

}

上面的代码重载了 =、==、!、!=、以及类型转换等操作符，这样变量就可以保持原有的使用方式

因为使用了模板的方式，所以在定义这些变量后，他们就是由我们定义的tepltTest类实例化出来的对象，C++不允许把类的对象转换为基本的数据类型，因此通过类型转换函数来解决这个问题。

定义类型转换函数一般形式：

operator 目标类型()
{
    ...
    return 目标类型的数据;
}

目标类型是所要转化成的类型名，既可以是预定义及基本类型也可以是自定义类型。类型转换函数的函数名(operator 目标类型)前不能指定返回类型，且没有参数。但在函数体最后一条语句一般为return语句，返回的是目标类型的数据。