クラステンプレート | Programming Place Plus　新C++編

std::vector<int> int_vector {};
std::vector<std::string> str_vector {};

// 同じかたちで変数を定義できる
RingBuffer<int> int_ringbuf {};
RingBuffer<std::string> str_ringbuf {};

// 同じような使い方ができる
int_vector.push_back(123);
int_ringbuf.push_back(123);
for (auto v : int_vector) {
    // ...
}
for (auto v : int_ringbuf) {
    // ...
}

template <typename T>
RingBuffer<T>::reference RingBuffer<T>::front()  // エラー
{
    assert(empty() == false);
    return m_data[m_front];
}

template <typename T>
typename RingBuffer<T>::reference RingBuffer<T>::front()  // OK
{
    assert(empty() == false);
    return m_data[m_front];
}

template <typename T>
class RingBuffer {
public:
    using container_type = typename std::vector<T>;                     // 内部コンテナの型

private:
    container_type              m_data;         // 要素
};

using value_type = typename container_type::value_type;

// ring_buffer.h
#ifndef RING_BUFFER_H_INCLUDED
#define RING_BUFFER_H_INCLUDED

#include <cassert>
#include <vector>

namespace mylib {

    // リングバッファ
    template <typename T>
    class RingBuffer {
    public:
        using container_type = typename std::vector<T>;                     // 内部コンテナの型
        using value_type = typename container_type::value_type;             // 要素型
        using reference = typename container_type::reference;               // 要素の参照型
        using const_reference = typename container_type::const_reference;   // 要素の const参照型
        using pointer = typename container_type::pointer;                   // 要素のポインタ型
        using const_pointer = typename container_type::const_pointer;       // 要素の constポインタ型
        using size_type = typename container_type::size_type;               // サイズ型

    public:
        // コンストラクタ
        //
        // size: 容量
        explicit RingBuffer(size_type capacity);


        // 要素を追加
        void push_back(const value_type& value);

        // 要素を取り除く
        void pop_front();

        // 空にする
        void clear();


        // 先頭の要素の参照を返す
        inline reference front()
        {
            assert(empty() == false);
            return m_data[m_front];
        }

        // 先頭の要素の参照を返す
        inline const_reference front() const
        {
            assert(empty() == false);
            return m_data[m_front];
        }

        // 末尾の要素の参照を返す
        inline reference back()
        {
            assert(empty() == false);
            return m_data[get_prev_pos(m_back)];
        }

        // 末尾の要素の参照を返す
        inline const_reference back() const
        {
            assert(empty() == false);
            return m_data[get_prev_pos(m_back)];
        }



        // 容量を返す
        inline size_type capacity() const
        {
            return m_data.size();
        }

        // 要素数を返す
        inline size_type size() const
        {
            return m_size;
        }

        // 空かどうかを返す
        inline bool empty() const
        {
            return m_size == 0;
        }

        // 満杯かどうかを返す
        inline bool full() const
        {
            return m_size == capacity();
        }

    private:
        // 次の位置を返す
        inline size_type get_next_pos(size_type pos) const
        {
            return (pos + 1) % capacity();
        }

        // 手前の位置を返す
        inline size_type get_prev_pos(size_type pos) const
        {
            if (pos >= 1) {
                return pos - 1;
            }
            else {
                return m_size - 1;
            }
        }

    private:
        container_type              m_data;         // 要素
        size_type                   m_size {0};     // 有効な要素の個数
        size_type                   m_back {0};     // 次に push される位置
        size_type                   m_front {0};    // 次に pop される位置
    };


    // コンストラクタ
    template <typename T>
    RingBuffer<T>::RingBuffer(size_type capacity) : m_data(capacity)
    {
    }

    // 要素を追加
    template <typename T>
    void RingBuffer<T>::push_back(const value_type& value)
    {
        if (full()) {
            m_front = get_next_pos(m_front);
        }
        else {
            m_size++;
        }

        m_data[m_back] = value;
        m_back = get_next_pos(m_back);
    }

    // 要素を取り除く
    template <typename T>
    void RingBuffer<T>::pop_front()
    {
        assert(empty() == false);

        m_front = get_next_pos(m_front);
        --m_size;
    }

    // 空にする
    template <typename T>
    void RingBuffer<T>::clear()
    {
        m_size = 0;
        m_back = 0;
        m_front = 0;
    }

}

#endif

template <テンプレート仮引数 = 型>

template <typename T1 = int, typename T2 = T1>

// T2 にデフォルトテンプレート実引数があるので、T3 にも必要
template <typename T1, typename T2 = double, typename T3>

template <typename T = int> // T のデフォルトは int
class C {
public:
    C(T a, T b, T c);

    inline T get() const
    {
        return m_value;
    }

private:
    T  m_value;
};

template <typename T>   // こちらにはデフォルト実引数の記述は不要
C<T>::C(T a, T b, T c) :
    m_value {a + b + c}
{
}

int main()
{
    C<> c1(1, 2, 3);     // OK. T は int
    C<int> c2(1, 2, 3);  // OK
}

template <typename T1 = int, typename T2 = double, typename T3 = double>
class C {
    // ...
};

// 先頭や途中のテンプレート実引数を省略することはできない
C<, int, int> c1(1, 2, 3);
C<int, , int> c2(1, 2, 3);

template <typename T1 = int, typename T2 = double, typename T3 = double>
class C {
    // ...
};

C<int, int, > c3(1, 2, 3);

template <テンプレート仮引数の宣言の並び>
using エイリアステンプレートの名前 = 元のクラステンプレートの名前<テンプレート仮引数の並び>;

template <typename T>
using CircularBuf = RingBuffer<T>;

CircularBuf<int> cir_buffer {};
RingBuffer<int> ring_buffer {};

template <typename T1, typename T2>
class C {};

template <typename T>
using Alias = C<T, int>;  // 第２テンプレート実引数を int に強制した C の別名

Alias<int> a1 {};     // C<int, int> と同等の型
Alias<double> a2 {};  // C<double, int> と同等の型

template <typename T1, typename T2>
class C {};

// T1、T2 を int にしてインスタンス化したあとのクラス型に対する別名を定義。
// 以下のどちらでも同じ。
typedef C<int, int> IntC;
using IntC = C<int, int>;

namespace std {
    using string = basic_string<char>;
    using ifstream  = basic_ifstream<char>;
    using ofstream  = basic_ofstream<char>;
    using fstream  = basic_fstream<char>;
}

template <typename T>
class C {
public:
    // ...

private:
    struct Data {
        T a;
        int b;
        int c;
    };

    std::vector<Data>   m_data;
};

template <typename T, typename Container>
class C {
public:
    // ...

private:
    struct Data {
        T a;
        int b;
        int c;
    };

    Container<Data> m_data;  // エラー。Container にテンプレート実引数は指定できない
};

C<int, std::deque> c {};  // エラー。テンプレート実引数の指定がない std::deque を渡せない

template <template <typename テンプレート仮引数の名前> class テンプレートテンプレート仮引数の名前>
class {
    // ...
};

または

template <template <class テンプレート仮引数の名前> class テンプレートテンプレート仮引数の名前>
class {
    // ...
};

template <typename T, template <typename T, typename Allocator = std::allocator<T>> class Container>
class C {
public:
    // ...

private:
    struct Data {
        T a;
        int b;
        int c;
    };

    Container<Data> m_data;
};

int main()
{
    C<int, std::deque> c {};
}

template <typename T, template <typename T> class Container>

template <typename T, template <typename T, typename Allocator = std::allocator<T>> class Container>

template <typename T, typename Allocator = std::allocator<T>> class vector;
template <typename T, typename Allocator = std::allocator<T>> class deque;