zoukankan      html  css  js  c++  java
  • 数组类模板(中)

    #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;   //数组类对象有可能是const的,此时只能调用const成员函数。
        virtual ~Array();
    };
    
    template
    < typename T, int N >
    int Array<T, N>::length()
    {
        return N;
    }
    
    template
    < typename T, int N >
    bool Array<T, N>::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<T, N>::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<T, N>::operator[] (int index)
    {
        return m_array[index];
    }
    
    template
    < typename T, int N >
    T Array<T, N>::operator[] (int index) const   //既然是const的,这里只能返回值,不能返回引用。
    {
        return m_array[index];
    }
    
    template
    < typename T, int N >
    Array<T, N>::~Array()
    {
    
    }
    
    #endif

    优化之前的IntArray类

    #ifndef _HEAPARRAY_H_
    #define _HEAPARRAY_H_
    
    template
    < typename T >
    class HeapArray
    {
    private:
        int m_length;
        T* m_pointer;
        
        HeapArray(int len);
        HeapArray(const HeapArray<T>& obj);
        bool construct();
    public:
        static HeapArray<T>* 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<T>& self();
        ~HeapArray();   //因为上面的构造函数被定义成了private,说明我不希望被继承,因此就不需要写virtual了
    };
    
    template
    < typename T >
    HeapArray<T>::HeapArray(int len)
    {
        m_length = len;
    }
    
    template
    < typename T >
    bool HeapArray<T>::construct()
    {   
        m_pointer = new T[m_length];
        
        return m_pointer != NULL;
    }
    
    template
    < typename T >
    HeapArray<T>* HeapArray<T>::NewInstance(int length) 
    {
        HeapArray<T>* ret = new HeapArray<T>(length);
        
        if( !(ret && ret->construct()) ) 
        {
            delete ret;
            ret = 0;
        }
            
        return ret;
    }
    
    template
    < typename T >
    int HeapArray<T>::length()
    {
        return m_length;
    }
    
    template
    < typename T >
    bool HeapArray<T>::get(int index, T& value)
    {
        bool ret = (0 <= index) && (index < length());
        
        if( ret )
        {
            value = m_pointer[index];
        }
        
        return ret;
    }
    
    template
    < typename T >
    bool HeapArray<T>::set(int index, T value)
    {
        bool ret = (0 <= index) && (index < length());
        
        if( ret )
        {
            m_pointer[index] = value;
        }
        
        return ret;
    }
    
    template
    < typename T >
    T& HeapArray<T>::operator [] (int index)
    {
        return m_pointer[index];
    }
    
    template
    < typename T >
    T HeapArray<T>::operator [] (int index) const
    {
        return m_pointer[index];
    }
    
    template
    < typename T >
    HeapArray<T>& HeapArray<T>::self()
    {
        return *this;
    }
    
    template
    < typename T >
    HeapArray<T>::~HeapArray()
    {
        delete[]m_pointer;
    }
    
    
    #endif
    #include <iostream>
    #include <string>
    #include "Array.h"
    #include "HeapArray.h"
    
    using namespace std;
    
    int main()
    {
        Array<double, 5> ad;
        
        for(int i=0; i<ad.length(); i++)
        {
            ad[i] = i * i;
        }
        
        for(int i=0; i<ad.length(); i++)
        {
            cout << ad[i] << endl;
        }
        
        cout << endl;
        
        HeapArray<char>* pai = HeapArray<char>::NewInstance(10);
        
        if( pai != NULL )
        {
            HeapArray<char>& ai = pai->self();
            
            for(int i=0; i<ai.length(); i++)
            {
                ai[i] = i + 'a';
            }
            
            for(int i=0; i<ai.length(); i++)
            {
                cout << ai[i] << endl;
            }
        }
        
        delete pai;
        
        return 0;
    }

    小结:
    模板参数可以是数值型参数
    数值型模板参数必须在编译期间唯一确定
    数组类模板是基于数值型模板参数实现的
    数组类模板是简易的线性表数据结构

  • 相关阅读:
    内功心法-代理模式
    java.lang.NumberFormatException: multiple points
    MarkDown语法-使用博客园的markDown编辑
    MarkDown语法
    linux下安装tomcat——service tomcat does not support chkconfig
    关于git&github的操作
    activeMQ 本地测试
    spring AOP 的坑~
    js高级面试题
    js的内存管理
  • 原文地址:https://www.cnblogs.com/-glb/p/12000177.html
Copyright © 2011-2022 走看看