34、不一样的C++系列-

发布时间:2017-6-29 10:00:45编辑:www.fx114.net 分享查询网我要评论
本篇文章主要介绍了"34、不一样的C++系列-",主要涉及到34、不一样的C++系列-方面的内容,对于34、不一样的C++系列-感兴趣的同学可以参考一下。

数组类模板

首先先了解一个小知识点:
模板参数可以是数值型参数(非类型参数),例如这样:

template
<typename T, int N>
void func()
{
    //使用模板参数定义局部数组
    T a[N];
}

//使用
func<double, 10>();

这种数值型模板参数也有很多限制:

  • 变量不能作为模板参数
  • 浮点数不能作为模板参数
  • 类对象不能作为模板参数
  • ……..

本质:模板参数是在编译阶段被处理的单元,因此,在编译阶段必须准确无误的唯一确定。

了解完数值型模板参数这个知识点以后,再来做一个面试题:

用一个最高效的方法求1+2+3+4+....+N的值!

或许大家会想到使用一个循环累加、递归、或者直接使用公式一步就可以得到结果。但这里介绍一个最高效的办法,和上面的小知识点有关:

#include <iostream>
#include <string>

using namespace std;

//定义一个函数模板
template
< typename T, int N >
void func()
{
    T a[N] = {0};

    int sum = 0;
    int i = 0;

    for(i=0; i<N; i++)
    {
        a[i] = i;
    }

    for(i=0; i<N; i++)
    {
        sum += a[i];
    }
    sum += i;

    cout << "func() " << N << " = "<< sum << endl;
}

//定义函数模板
template
< int N >
class Sum
{
public:
    //递归
    static const int VALUE = Sum<N-1>::VALUE + N;
};

//定义函数模板,参数直接固定,且为数值
template
< >
class Sum < 1 >
{
public:
    static const int VALUE = 1;
};

int main()
{
    func<int, 10>();
    func<int, 100>();

    cout << "1 + 2 + 3 + ... + 10 = " << Sum<10>::VALUE << endl;
    cout << "1 + 2 + 3 + ... + 100 = " << Sum<100>::VALUE << endl;

    return 0;
}

输出结果为:

func() 10 = 55
func() 100 = 5050
1 + 2 + 3 + ... + 10 = 55
1 + 2 + 3 + ... + 100 = 5050

是不是会有疑问,代码中表述了2中方式的求值过程。第一种是正常的方法,直接for循环来累加求值;第二种是使用函数模板递归来求值。可是这两种方式没有什么不同呀!

其实这里是有区别的,我们都知道对于函数模板编译器是分两次编译。那在这里对于func函数模板,第一次编译是编译函数模板本身,第二次是替换参数后的代码,也就是说最终的值是在运行期main函数中调用这个函数,传入参数,然后求值;那对于sum函数模板,就不一样了,第一次是编译函数模板本身,但是这里是使用递归,那就是说第一次编译的时候就已经把值求出来,第二次编译是有一个静态变量存在函数体中。

对于两种方法,第一个是在运行期求值,会消耗掉计算量,第二个是在编译器就求出来了,运行期直接输出,不消耗任何计算量。所以第二个方法更高效。

最后在这里用代码阐述array类的内部实现过程,分两种实现,一种是在栈上开辟空间,一种是在堆上开辟空间:

在栈上开辟空间演示(Array.h)

#ifndef _ARRAY_H_
#define _ARRAY_H_

template
< typename T, int N >
class Array
{
    //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<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 >
Array<T, N>::~Array()
{

}

#endif

在堆上开辟空间演示(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<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();
};

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

调用函数(main.cpp):

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

运行结果为:

0
1
4
9
16

a
b
c
d
e
f
g
h
i
j


上一篇:Heap size check 堆大小检查
下一篇:shell eval命令使用

相关文章

相关评论

本站评论功能暂时取消,后续此功能例行通知。

一、不得利用本站危害国家安全、泄露国家秘密,不得侵犯国家社会集体的和公民的合法权益,不得利用本站制作、复制和传播不法有害信息!

二、互相尊重,对自己的言论和行为负责。

好贷网好贷款