数组类模板、单例类模板

数组类模板

1、编程实验 

数组模板类     Array.h 

#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  

和柔性数组相比如何？

2、编程实验 

堆数组模板类     HeapArray.h

#ifndef _HEAPARRAY_H_  
#define _HEAPARRAY_H_  
  
template  
< typename T >  
class HeapArray  
{  
private:  
    int m_length;  
    T* m_pointer;  
      
    HeapArray(int len);  
    HeapArray(const HeapArray& obj);  
    bool construct();  
public:  
    static HeapArray* NewInstance(int length);   
    int length();  
    bool get(int index, T& value);  
    bool set(int index ,T value);  
    T& operator [] (int index);  
    T operator [] (int index) const;  
    HeapArray& self();  
    ~HeapArray();  
};  
  
template  
< typename T >  
HeapArray::HeapArray(int len)  
{  
    m_length = len;  
}  
  
template  
< typename T >  
bool HeapArray::construct()  
{     
    m_pointer = new T[m_length];  
      
    return m_pointer != NULL;  
}  
  
template  
< typename T >  
HeapArray* HeapArray::NewInstance(int length)   
{  
    HeapArray* ret = new HeapArray(length);  
      
    if( !(ret && ret->construct()) )   
    {  
        delete ret;  
        ret = 0;  
    }  
          
    return ret;  
}  
  
template  
< typename T >  
int HeapArray::length()  
{  
    return m_length;  
}  
  
template  
< typename T >  
bool HeapArray::get(int index, T& value)  
{  
    bool ret = (0 <= index) && (index < length());  
      
    if( ret )  
    {  
        value = m_pointer[index];  
    }  
      
    return ret;  
}  
  
template  
< typename T >  
bool HeapArray::set(int index, T value)  
{  
    bool ret = (0 <= index) && (index < length());  
      
    if( ret )  
    {  
        m_pointer[index] = value;  
    }  
      
    return ret;  
}  
  
template  
< typename T >  
T& HeapArray::operator [] (int index)  
{  
    return m_pointer[index];  
}  
  
template  
< typename T >  
T HeapArray::operator [] (int index) const  
{  
    return m_pointer[index];  
}  
  
template  
< typename T >  
HeapArray& HeapArray::self()  
{  
    return *this;  
}  
  
template  
< typename T >  
HeapArray::~HeapArray()  
{  
    delete[]m_pointer;  
}  
  
  
#endif  

main.cpp

#include   
#include   
#include "Array.h"  
#include "HeapArray.h"  
  
using namespace std;  
  
int main()  
{  
    Array ad;  
      
    for(int i=0; i* pai = HeapArray::NewInstance(10);  
      
    if( pai != NULL )  
    {  
        HeapArray& ai = pai->self();  
          
        for(int i=0; i

 

 

3、小结

            模板参数可以是数值型参数 

            数值型模板参数必须在编译期间唯—确定 

            数组类模板是基于数值型模板参数实现的 

            数组类模板是简易的线性表数据结构

单例类模板

1、单例模式

需求的提出 

        - 在架构设计时，某些类在整个系统生命期中最多只能有—个对象存在(Single Instance)。 

            如何定义—个类，使得这个类最多只能创建—个对象？ 

2、问题分析

            要控制类的对象数目，必须对外隐藏构造函数

            思路：

                －将构造函数的访问属性设置为private 

                 - 定义instance并初始化为NULL 

                －当需要使用对象时，访问instance的值 

                        ★ 空值：创建对象，并用instance标记 

                        ★ 非空值：返回instance标记的对象 

 

3、编程实验 

单例模式初探     62-1.cpp

#include   
  
using namespace std;  
  
class SObject  
{  
    static SObject* c_instance;  
      
    SObject(const SObject&);  
    SObject& operator= (const SObject&);  
      
    SObject()  
    {  
        //隐藏构造函数，达到无法在外部创建对象的目的
    }  
public:  
    static SObject* GetInstance();  //提供一个接口创建和访问唯一的对象
      
    void print()  
    {  
        cout << "this = " << this << endl;  
    }  
};  
  
SObject* SObject::c_instance = NULL;  
  
SObject* SObject::GetInstance()  
{  
    if( c_instance == NULL )  
    {  
        c_instance = new SObject();  
    }  
      
    return c_instance;  
}  
  
int main()  
{  
    SObject* s = SObject::GetInstance();  
    SObject* s1 = SObject::GetInstance();  
    SObject* s2 = SObject::GetInstance();  
      
    s->print();  
    s1->print();  
    s2->print();  
      
    return 0;  
}  

  

存在的问题 

                －需要使用单例模式时： 

                        必须定义静态成员变量c_instance 

                        必须定义静态成员函数Getlnstance() 

            解决方案 

                    将单例模式相关的代码抽取出来，开发单例类 

                    模板。当需要单例类时，直接使用单例类模板。

 

4、编程实验 

单例类模板     62-2.cpp

Singleton.h

#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

62-2.cpp

#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;  
}  

  

 

5、小结

            单例模式是开发中最常用的设计模式之— 

            单例模式的应用使得—个类最多只有—个对象 

            可以将单例模式相关的代码抽象成类模板 

            需要使用单例模式的类直接使用单例类模板