C++学习之模板应用 ---array、smartptr、stack

有array（数组）、smartptr（智能指针）、stack（栈）；

一、array：

1、我们实现了指针访问和下标访问。C++中指针访问常用迭代器来代替。

2、这里我们也揭示了 size_type、iterator、[] 、begin()、end()、size()的真实面目；

Array.hpp

#ifndef ARRAY_H_
#define ARRAY_H_
//Arrar.hpp
#include <stddef.h>
template <typename T, int MAXSIZE>
class Array
{
    public:
        //我们假设T为int型
        typedef T value_type;  //int
        typedef T *iterator;   // int*->将int* 重定义为interator
        typedef const T* const_iterator;
        typedef T &reference; //int& -->将int& 重定义为reference
        typedef const T& const_reference;
        typedef size_t size_type;//size_type常用于vector<int>::size_type 下表访问
　
        iterator begin()//begin返回的是首地址
        { return elems_; }
        const_iterator begin()const
        { return elems_; }

        iterator end()//end返回的是末尾元素的下个地址
        { return elems_+ MAXSIZE; }
        const_iterator end()const
        { return elems_+ MAXSIZE; }

        reference operator[](size_type index)//下标访问返回的是对本身的引用
        { return elems_[index]; }
        const_reference operator[](size_type index)const
        { return elems_[index]; }

        size_type size()const  //int->元素个数
        { return MAXSIZE;}
    private:
        T elems_[MAXSIZE];
};

#endif

main.cpp：

#include "Array.hpp"
#include <iostream>
#include <algorithm>
using namespace std;

template <typename T>
void print(const T &t)
{
    for(typename T::const_iterator it = t.begin(); //迭代器实现打印
         it!= t.end();
         it++)
    {
        cout << *it << " ";
    }
    cout << endl;
}

int main(int argc, const char *argv[])
{
    Array<int, 20> arr;

    for(Array<int, 20>::size_type ix =0;   //下标实现初始化
        ix != arr.size();
        ix ++)
    {
        arr[ix] = ix;
    }
    
    print(arr);
    
    Array<int, 20>::const_iterator it=std::find(arr.begin(), arr.end(), 15);
    cout << *it << endl; //标准库中的find函数

    return 0;
}

二、智能指针：
这里我们实现了指针的一些操作， 如解引用操作符，->操作符、指针的复制与赋值。

代码如下：

SmartPtr.hpp

#ifndef SMARTPTR_H_
#define SMARTPTR_H_

#include <stddef.h>

template <typename T>
class SmartPtr
{
    public:
        SmartPtr(T *ptr= NULL ); //如果没有提供ptr的值，编译器会将其默认为NULL
        ~SmartPtr();

        T &operator*() //解引用操作返回的是本身值的引用
        { return *ptr_; }
        const T &operator*()const
        { return *ptr_; }
        
        T *operator->() //->操作 返回的是 指针本身；
        { return ptr_;}
        const T *operator->()const
        { return ptr_;}

        void resetPtr(T *ptr = NULL); //将 指针重置
        const T *getPtr()const //获取该指针
        { return ptr_; }

    private:
        //这里我们禁用了智能指针的复制和赋值能力
        SmartPtr(const SmartPtr&); 
        SmartPtr &operator=(const SmartPtr&);

        T *ptr_;  
};

template <typename T>
SmartPtr<T>::SmartPtr(T *ptr )
    :ptr_(ptr)
{ }

template <typename T>
SmartPtr<T>::~SmartPtr()
{ delete ptr_; } 

template <typename T>
void SmartPtr<T>::resetPtr(T *ptr )
{
    if(ptr_ == ptr) //如果把自己本身赋值给自己，则直接返回
        return;
    delete ptr_;
    ptr_ = ptr ;
}

#endif

main.cpp：

#include "SmartPtr.hpp"
#include <iostream>
using namespace std;

class Test
{
    public:

        Test() {cout << "construct" << endl; }
        ~Test(){cout << "~construct" << endl; }
};

int main(int argc, const char *argv[])
{
    SmartPtr<Test> sp(new Test); 

    return 0;
}

三、Stack 及其特化：

1、这里我们揭示了Stack 的 pop、push、top、empty操作；

2、对于一些特殊的类型，如 const char*（C风格的字符串），当我们用push函数时，总会出现一些问题，原因在于：

push函数复制给定值以创建 stack中的新元素（值拷贝），而默认情况下，复制C 风格字符串只会复制其指针，不会复制字符串（衰退【decay】），这时复制指针将会出现共享指针在其他环境中会出现的所有问题（如重复析构），最严重的是，若指针指向动态内存，用户就有可能删除指针所指的数组。

//Stack.hpp
#ifndef STACK_H_
#define STACK_H_

#include <vector>
#include <stdexcept>

//Stack-----------------------
template <typename T>
class Stack
{
    public:
        void push(const T &t);
        void pop();
        T top()const; 

        bool empty()const
        { return elems_.empty(); }
    private:
        std::vector<T> elems_;
};

template <typename T>
void Stack<T>::push(const T &t)
{
    elems_.push_back(t);
}

template <typename T>
void Stack<T>::pop()
{
    if( !elems_.empty() )
        elems_.pop_back();
    else
        throw std::out_of_range("out of range");
}

template <typename T>
T Stack<T>::top()const 
{
    if( !elems_.empty() )
        return elems_.back();
    else
        throw std::out_of_range("out of range");
}
//----------------------------

//特化------------------
template <>
class Stack<const char*>
{
    public:
        void push(const char *);
        void pop();
        const std::string top()const;  
       //注意上面的函数返回的是string，为了避免管理字符数组char[]
        bool empty()const
        { return elems_.empty(); }
    private:
        std::vector<std::string> elems_; //通过这一数据元素实现以上各个功能
};

void Stack<const char*>::push(const char*t)
{
    elems_.push_back(t);
}

void Stack<const char*>::pop()
{
    if( !elems_.empty() )
        elems_.pop_back();
    else
        throw std::out_of_range("out of range");
}

const std::string Stack<const char*>::top()const 
{
    if( !elems_.empty() )
        return elems_.back();
    else
        throw std::out_of_range("out of range");
}
//----------------

#endif

main.cpp

//main.cpp
#include "Stack.hpp"
#include <iostream>
using namespace std;

int main(int argc, const char *argv[])
{
    try
    {
        const char *s1 = "foo";
        Stack<const char *> st;
        
        st.push(s1);
        st.push("bar");
        
        cout << st.top() << endl;
        st.pop();

        cout << st.top() << endl;
        st.pop();

    }
    catch(exception &e)
    {
        cout << e.what()<< endl;
    }
    return 0;
}