深入理解模板1

深入理解模板1

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

template<class T,size_t N>
class Stack
{
    T       data[N];
    size_t  nCount;

public:
    void push(const T& t);
}
// 当需要模板一个实例时，则为 Stack<int, 100> myFixedStack

// 默认模板参数
template<class T,size_t N = 100>
class Stack
{
    T       data[N];    // Fixed Capacity is N
    size_t  nCount;

public:
    void push(const T& t);
}

// 则声明模板为 Stack<int> myStack == Stack<int, 100>  myStack


// 或者
template<class T = int,size_t N = 100>
class Stack
{
    T       data[N];    // Fixed Capacity is N
    size_t  nCount;

public:
    void push(const T& t);
}

// 则声明默认的栈为  Stack<>  myStack  ==   Stack<int, 100>  myStack

// 模板类型的模板参数
#include <cstddef>
#include <iostream>

using namespace std;

template<class T>
class Array
{
    enum{ INIT = 10 };

    T*      data;
    size_t  capacity;
    size_t  count;

public:
    Array()
    {
        count = 0;
        data = new T[capacity = INIT];
    }

    ~Array()
    {
        delete [] data;
    }

    // 入栈
    void push(const T& t)
    {
        // 栈已满
        if(count == capacity)
        {
            // 重新分配空间， 原先容量的两倍
            size_t newCap = capacity * 2;
            T* newData = new T[newCap];
            
            for(int i = 0; i < count; i++)
            {
                newData[i] = data[i];
            }

            delete [] data;
            data = newData;
            capacity = newCap;
        }

        data[count++] = t;
    }


    // 出栈
    void  pop_push()
    {
        if(count > 0)
            --count;
    }

    T* begin()  {  return data; }
    T* end()    {  return data+count; }

};


// 把 Stack 作为模板  template<class> 中的 默认为 template<class T>
template<class T, template<class> class Seq>
class Container
{
    Seq<T> seq;
public:
    void append(const T& t)  { seq.push_back(t);   }
    T*   begin()             { return seq.begin(); }
    T*   end()               { return seq.end();   }
};

int main()
{
    // 以模板作为另一个模板类的参数
    Container<int, Array>   container;
    container.append(1);
    container.append(2);
    int* p = container.begin();
    while(p != container.end())
    {
        std::cout<<*p++<<std::endl;
    }

    system("pause");
    return 0;
}

// 若Array 模板类为两个参数，则为
#include <cstddef>
#include <iostream>

using namespace std;

template<class T, size_t N>
class Array
{
    T      data[N];
    size_t  count;

public:
    Array()
    {
        count = 0;
    }

    ~Array()
    {
    }

    // 入栈
    void push(const T& t)
    {
        // 栈已满
        if(count < N)
        {
            data[count++] = t;
        }
    }

    T* begin()  {  return data; }
    T* end()    {  return data+count; }

};


// 把 Stack 作为模板  template<class> 中的 默认为 template<class T>
template<class T, size_t N, template<class, size_t> class Seq>
class Container
{
    Seq<T,N> seq;
public:
    void append(const T& t)  { seq.push_back(t);   }
    T*   begin()             { return seq.begin(); }
    T*   end()               { return seq.end();   }
};

int main()
{
    // 以模板作为另一个模板类的参数
    const size_t N = 10;
    Container<int, N, Array>   container;
    container.append(1);
    container.append(2);
    int* p = container.begin();
    while(p != container.end())
    {
        std::cout<<*p++<<std::endl;
    }

    system("pause");
    return 0;
}


// 若容量大小为默认的值  10 则为：

template<class T, size_t N = 100>

// Container 的定义和构造
template<class T, template<class, size_t N = 10> class Seq>
class Container
{
    Seq<T> seq;
public:
    void append(const T& t)  { seq.push_back(t);   }
    T*   begin()             { return seq.begin(); }
    T*   end()               { return seq.end();   }
};


int main()
{
    // 以模板作为另一个模板类的参数
    Container<int, Array>   container;
    container.append(1);
    container.append(2);
    int* p = container.begin();
    while(p != container.end())
    {
        std::cout<<*p++<<std::endl;
    }

    system("pause");
    return 0;
}