C++语言学习（十七）——模板

2、数组模板

#ifndef _ARRAY_H_
#define _ARRAY_H_

template
< typename T, int N >
class Array
{
    T m_array[N];
public:
    int length();
    bool set(int index, T value);
    bool get(int index, T& value);
    T& operator[] (int index);
    T operator[] (int index) const;
    virtual ~Array();
};

template
< typename T, int N >
int Array::length()
{
    return N;
}

template
< typename T, int N >
bool Array::set(int index, T value)
{
    bool ret = (0 <= index) && (index < N);
    if( ret )
    {
        m_array[index] = value;
    }
    return ret;
}

template
< typename T, int N >
bool Array::get(int index, T& value)
{
    bool ret = (0 <= index) && (index < N);
    if( ret )
    {
        value = m_array[index];
    }
    return ret;
}

template
< typename T, int N >
T& Array::operator[] (int index)
{
    return m_array[index];
}

template
< typename T, int N >
T Array::operator[] (int index) const
{
    return m_array[index];
}

template
< typename T, int N >
Array::~Array()
{

}

#endif

六、智能指针类模板

智能指针是C++开发库的重要类模板之一，是自动内存管理的主要手段，可以避开内存的相关问题。

1、STL的智能指针

STL中的智能指针分为auto_ptr、shared_ptr、weak_ptr、unique_ptr四类。
auto_ptr智能指针的特性：
A、生命周期结束时，销毁指向的内存空间
B、不能指向堆数组，只能指向堆对象
C、一块堆空间只能属于一个智能指针
D、多个智能指针对象不能指向同一块空间
shared_ptr智能指针的特性：
带有引用计数机制，支持多个指针指向同一对象内存空间。
weak_ptr智能指针的特性：
weak_ptr是一种弱引用，指向shared_ptr所管理的对象。
unique_ptr智能指针的特性：
一个指针对象指向一片内存空间，不能拷贝构造和赋值

STL智能指针使用实例：

#include 
#include 

using namespace std;

class Test
{
    string m_name;
public:
    Test(const char* name)
    {
        cout << "Hello, " << name << "." << endl;
        m_name = name;
    }

    void print()
    {
        cout << "I'm " << m_name << "." << endl;
    }

    ~Test()
    {
        cout << "Goodbye, " << m_name << "." << endl;
    }
};

int main(int argc, char *argv[])
{
    auto_ptr pt(new Test("D.T.Software"));
    cout << "pt = " << pt.get() << endl;
    pt->print();
    cout << endl;

    auto_ptr pt1(pt);
    cout << "pt = " << pt.get() << endl;//NULL
    cout << "pt1 = " << pt1.get() << endl;//

    return 0;
}

2、QT中的智能指针

QT中的主要智能指针有：QPointer、QSharedPointer、QWeakPointer、QScopedPointer、QSharedDataPoiner、QExplicitlySharedDataPointer。
QPointer智能指针特性：
A、当其所指向的对象被销毁时会被自动置空
B、析构时不会自动销毁所指向的对象
多个QPointer指针对象可以指向同一内存空间，当所指向对象被销毁时指针会被自动置空，但是指针对象析构时不会自动销毁所指向的对象。
QSharedPointer智能指针特性：
A、引用计数型智能指针
B、可以被自由的拷贝和赋值
C、当引用计数为0时才删除指向的对象
QT中智能指针使用实例：

#include 
#include 
#include 

class Test : public QObject
{
    QString m_name;
public:
    Test(const char* name)
    {
        qDebug() << "Hello, " << name << ".";

        m_name = name;
    }

    void print()
    {
        qDebug() << "I'm " << m_name << ".";
    }

    ~Test()
    {
        qDebug() << "Goodbye, " << m_name << ".";
    }
};

int main()
{
    QPointer pt(new Test("D.T.Software"));
    QPointer pt1(pt);
    QPointer pt2(pt);//多个QPointer指针对象可以指向同一内存空间

    pt->print();
    pt1->print();
    pt2->print();

    delete pt;//QPointer智能指针指向的对象被销毁时，指针对象被置空

    qDebug() << "pt = " << pt;//NULL
    qDebug() << "pt1 = " << pt1;//NULL
    qDebug() << "pt2 = " << pt2;//NULL

    qDebug() << endl;

    QSharedPointer spt(new Test("Delphi Tang"));
    QSharedPointer spt1(spt);
    QSharedPointer spt2(spt);

    spt->print();
    spt1->print();
    spt2->print();

    return 0;//指针对象都被销毁时引用计数为0，自动析构指针指向的对象
}

3、智能指针类模板

#ifndef _SMARTPOINTER_H_
#define _SMARTPOINTER_H_

template
< typename T >
class SmartPointer
{
    T* mp;
public:
    SmartPointer(T* p = NULL)
    {
        mp = p;
    }

    SmartPointer(const SmartPointer& obj)
    {
        mp = obj.mp;
        const_cast&>(obj).mp = NULL;
    }

    SmartPointer& operator = (const SmartPointer& obj)
    {
        if( this != &obj )
        {
            delete mp;
            mp = obj.mp;
            const_cast&>(obj).mp = NULL;
        }

        return *this;
    }

    T* operator -> ()
    {
        return mp;
    }

    T& operator * ()
    {
        return *mp;
    }

    bool isNull()
    {
        return (mp == NULL);
    }

    T* get()
    {
        return mp;
    }

    ~SmartPointer()
    {
        delete mp;
    }
};

#endif

七、单例类模板

某些类在整个系统的生命周期中只能有一个对象存在，即单例模式。
要控制类的对象数目必须隐藏类的构造函数，即构造函数声明为private。
定义一个instance标识符，初始化为NULL，当需要使用对象时查看instance的值，如果instance为NULL则创建对象并用instance标识，如果instance非空则返回instance标识的值。

#ifndef _SINGLETON_H_
#define _SINGLETON_H_

template
< typename T >
class Singleton
{
    static T* c_instance;
public:
    static T* GetInstance();
};

template
< typename T >
T* Singleton::c_instance = NULL;

template
< typename T >
T* Singleton::GetInstance()
{
    if( c_instance == NULL )
    {
        c_instance = new T();
    }

    return c_instance;
}

#endif

使用代码：

#include 
#include 
#include "Singleton.h"

using namespace std;

class SObject
{
    friend class Singleton;    // 当前类需要使用单例模式

    SObject(const SObject&);
    SObject& operator= (const SObject&);

    SObject()
    {
    }
public:

    void print()
    {
        cout << "this = " << this << endl;
    }
};

int main()
{
    SObject* s = Singleton::GetInstance();
    SObject* s1 = Singleton::GetInstance();
    SObject* s2 = Singleton::GetInstance();

    s->print();
    s1->print();
    s2->print();

    return 0;
}

八、模板应用示例

判断一个变量是不是指针
C++编译器匹配的调用优先级：
A、重载函数
B、函数模板
C、变参函数
可以根据C++编译器匹配的调用优先级，将函数模板匹配指针变量，返回true，变参函数匹配非指针变量，返回false。

template

bool IsPtr(T *pt)
{
    return true;
}

bool IsPtr(...)
{
    return false;
}

但是，由于变参函数是C语言的内容，无法解析C++自定义类型对象，可能造成程序崩溃。

template

char IsPtr(T* v) // match pointer
{
    return 'd';
}

int IsPtr(...)  // match non-pointer
{
    return 0;
}

#define ISPTR(p) (sizeof(IsPtr(p)) == sizeof(char))

上述代码中，C++编译器在编译时会进行函数匹配，不会进行调用，避免了参数为自定义对象时调用变参函数导致的程序崩溃。

九、class与typename关键字

C++语言在引入了面向对象编程思想时，使用class关键字定义类类型。C++语言发展过程中引入了泛型编程，直接复用class关键字来定义模板。但泛型编程针对的不只是类类型，直接复用class关键字会使代码出现二义性。因此，C++直接引入了typename关键字，用于在模板定义中声明泛指类型，明确告诉C++编译器声明的标识符为类型。
C++语言中允许类定义中嵌套类型，因此当自定义类类型中嵌套类型的标识符与其它类类型中定义的成员变量标识符重名时将会造成二义性。不同类中的同名标识符代表可能导致二义性，因此C++编译器无法识别标识符的确切意义。

#include 

using namespace std;

class Test1
{
public:
    static const int NS = 1;
};

class Test2
{
public:
    struct NS
    {
        int value;
    };
};

int a = 0;

template 
void func()
{
    T::NS* a;
}

int main(int argc, char *argv[])
{
    func();
    //func();//error
    //error: dependent-name 'T:: NS' is parsed as a non-type,
    //but instantiation yields a type
    //say 'typename T:: NS' if a type is meant

    return 0;
}

上述代码中，C++编译器不会将func函数模板中NS解析为类型，因此使用Test2作为参数时，C++编译器会报错。因此，为了将NS明确声明为类型，需要使用typename关键字对NS标识符进行声明。代码如下：

#include 

using namespace std;

class Test1
{
public:
    static const int NS = 1;
};

class Test2
{
public:
    struct NS
    {
        int value;
    };
};

int a = 0;

template 
void func()
{
    typename T::NS* a;
}

int main(int argc, char *argv[])
{
    //func();//error
    func();
    return 0;
}

上述代码中，NS被明确声明为类型，因此如果使用Test1作为参数，func函数模板将会报错。