有時候需要定義全域性變數供多個執行緒使用，為了對變數進行保護，需要對其進行加鎖的操作

如果全域性變數較多，每個變數都進行加鎖的操作，會導致程式碼繁瑣混亂

使用類模板，可以將加鎖/解鎖的操作統一

#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語句，返回的是目標型別的資料。