数值型模板参数的应用

目录

　　1. 初识数值型模板参数

　　2. 数值型模板参数的应用

1、初识数值型模板参数

　　在泛型编程中，数据的值和类型都被参数化。在第二次编译时，编译器会根据模板中的类型参数<实参.>去推导形参的值与类型；也就是说，模板不仅支持值的传递，还支持类型的传递，这就是模板与普通函数的最大区别了。

　　模板参数可以是数字型参数，也可以是类型参数；接下来我们以代码来说明什么是数值型模板参数？

template <typename T, int N> 
void func()
{
    T a[N];  // 使用模板参数定义局部数组；
}
           
func<double, 10>();  // 使用模板时，数值型参数必须是常量，不能是变量；

　　代码中 N 就是模板中的数值型参数，当发生函数调用时，这个数值型参数就被初始化为常量 10；

　　那么什么才是合法的数值型模板参数呢？

　　1. 在发生调用时，变量不能作为数值型模板参数；（在编译时，变量的值还没有唯一确定；如 int a = 10; func<double, a>(); 编译失败）

　　2. 在模板声明时，浮点数不能作为数值型模板参数；（浮点数本身就不精确；如 template <typename T, double N> 编译失败 ）

　　3. 类对象不能作为数值型模板参数；（类对象的属性包含了1、2 这两点）

　　....

　　总之，合法的数值型模板参数必须满足，在编译阶段确保数值型模板参数是唯一确定的。

2、数值型模板参数的应用

　1. 用你觉得最高效的方法求 1 + 2 + 3 + ... + N 的值；

　　　求前N项和的方法有很多，比如 for 循环求取（栈空间、堆空间）、等差数列求和（公式法）、递归求取等等。但是题中明确指定是最高效的求和方法，怎么做呢？接下来我们分别分析这三种方法：

　　 （1）如果用 for循环、递归求取，会随着项数N的增多，导致程序的执行步骤也会增加；显然这时候公式法就比较合适了；（程序执行的步骤是判断算法执行效率的方式之一）

　　 （2）但是，如何使求和算法做到最高效呢？试想我们能不能站在内存的角度考虑，如果能将这前N项和的结果直接存储在内存中，当我们需要时，直接从内存中读取是不是会更高效呢。

　　有了上面的铺垫，现在我们就带着这种思想去实现这个算法（涉及内容：类模板的完全特化、模板的数值型参数、static 和 const 关键字、递归算法）。

#include <iostream>
#include <string>

using namespace std;

template
< int N >
class Sum
{
public:
    static const int VALUE = Sum<N-1>::VALUE + N;   // 递归思想：如果知道了前（N-1）项的结果，再加上第N项的结果就可以求出前N项和的结果
};

/* 定义上述类模板的完全特化实现，实现递归出口 N = 1 */
template
< >
class Sum < 1 >
{
public:
    static const int VALUE = 1;
};

/**
* static const int VALUE = 1;
* 1 用字面量去初始化const常量，编译器会将该常量放入符号表中，当使用该常量时，再从符号表中取出该常量的值；
* 2 static 会把所修饰的变量存储到全局数据区，方便让所有对象共享；
* 3 所以，static const 的组合使用会将符号表放入到全局数据区；
*/

int main()
{
    cout << "1 + 2 + 3 + ... + 10 = " << Sum<10>::VALUE << endl;
    cout << "1 + 2 + 3 + ... + 100 = " << Sum<100>::VALUE << endl;
    
    return 0;
}

/**
 * 运行结果：
 * 1 + 2 + 3 + ... + 10 = 55
 * 1 + 2 + 3 + ... + 100 = 5050
 */

　　通过这个案列，我们要学会举一反三，从而写出更高效的程序。

　2. 数组模板类的实现

　　（1）栈空间创建数组模板类

// array.hpp 数组模板类文件
#ifndef ARRAY_H
#define ARRAY_H

#include <iostream>

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 成员函数，所以要定义这个；const 函数只能返回值，不能返回引用；
    void print();
    void sort();
    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
{
    return m_array[index];
}

template
< typename T, int N >
void Array<T, N>::print()
{
    for(int i=0; i< N; i++)
    {
        std::cout << m_array[i] << "  ";
    }
    
    std::cout << std::endl;
}

template
< typename T >
void Swap(T& a, T& b)
{
    T c = a;
    a = b;
    b = c;
}

template
< typename T, int N >
void Array<T, N>::sort()
{
    for(int i=0; i<N; i++)
    {
        for(int j=i; j<N; j++)
        {
            if( m_array[i] > m_array[j] )
            {
                Swap(m_array[i], m_array[j]);
            }
        }
    }
}

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

}

#endif

// main.cpp 测试文件

#include <iostream>
#include <string>
#include "array.hpp"

using namespace std;

int main()
{
    Array<double, 5> ad;  //  相当于 double[5]
    
    for(int i=0; i<ad.length(); i++)
    {
        ad[i] = 100 - i * 0.5;
    }
    
    ad.print(); // 100  99.5  99  98.5  98
    ad.sort();  // 升序排列
    ad.print(); // 98  98.5  99  99.5  100
    
    Array<int, 5> ai;  // 相当于 int[5]
    
    for(int i=0; i<ai.length(); i++)
    {
        ai[i] = i * i;
    }
    
    ai.print(); // 0  1  4  9  16
    
    return 0;
}

　　（2）堆空间创建数组模板类 

// heapArray.hpp 数组模板类文件
#ifndef HEAPARRAY_H
#define HEAPARRAY_H

template
< typename T, int N >   // 数组元素的类型和大小；
class HeapArray
{
private:
    T* m_pointer;
    
    HeapArray();
    HeapArray(const HeapArray<T, N>& obj);
    bool construct();
public:
    static HeapArray<T, N>* NewInstance(); 
    int length();
    bool get(int index, T& value);
    bool set(int index ,T value);
    T& operator [] (int index);
    T operator [] (int index) const;  // 有可能有 const 对象；
    HeapArray<T, N>& self();
    ~HeapArray();  // 这个时候构造函数是 private 的，也就是 HeapArray 类不希望被继承，所以说没有必要将它声明为 virtual 的；
};

/* 声明与实现要在同一个文件中 */

template
< typename T, int N >
HeapArray<T, N>::HeapArray()
{
    // 与资源无关的操作
}

template
< typename T, int N >
bool HeapArray<T, N>::construct()
{   
    m_pointer = new T[N];   // 申请内存
    
    return m_pointer != 0;
}

template
< typename T, int N >
HeapArray<T, N>* HeapArray<T, N>::NewInstance() 
{
    HeapArray<T, N>* ret = new HeapArray<T, N>();
    
    if( !(ret && ret->construct()) ) 
    {
        delete ret;
        ret = 0;
    }
        
    return ret;
}

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

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

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

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

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

template
< typename T, int N >
HeapArray<T, N>& HeapArray<T, N>::self()
{
    return *this;
}

template
< typename T, int N >
HeapArray<T, N>::~HeapArray()
{
    delete[]m_pointer;
}

#endif

// main.cpp 测试文件

#include <iostream>
#include <string>
#include "heapArray.hpp"

using namespace std;

int main()
{   
    HeapArray<char, 10>* pac = HeapArray<char, 10>::NewInstance();  // 在堆区申请 10 char
    
    if( pac != NULL )
    {
        HeapArray<char, 10>& ac = pac->self();
        
        for(int i=0; i<ac.length(); i++)
        {
            ac[i] = i + 'a';
        }
        
        for(int i=0; i<ac.length(); i++)
        {
            cout << ac[i] << " ";
        }
        
        cout << endl;
    }
    
    delete pac;

    
    HeapArray<int, 10>* pai = HeapArray<int, 10>::NewInstance();    // 在堆区申请 10 int
    
    if( pai != NULL )
    {
        HeapArray<int, 10>& ai = pai->self();
        
        for(int i=0; i<ai.length(); i++)
        {
            ai[i] = i + 1;
        }
        
        for(int i=0; i<ai.length(); i++)
        {
            cout << ai[i] << " ";
        }
        
        cout << endl;
    }
    
    delete pai;
    
    return 0;
}
/**
 * 运行结果：
 * a b c d e f g h i j 
 * 1 2 3 4 5 6 7 8 9 10
 */

 本节总结： 

    1，模板参数可以是数值型参数；

    2，数值型模板参数必须在编译期间唯一确定；

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

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