読者です 読者をやめる 読者になる 読者になる

私のひらめき日記

もっと自由に、流暢にプログラミングする

コンパイル時階乗計算まとめ

まずは、関数テンプレートの明示的特殊化バージョンから。*1

template<int N>
int factorial()
{
    return factorial<N-1>() * N;
}

template<>
int factorial<0>()
{
    return 1;
}

int main(void)
{
    cout << factorial<4>() << endl;
    return 0;
}

関数テンプレートのコンパイル時計算には、もう一つ問題があって、部分特殊化ができない:

#include <iostream>
using namespace std;

//template<typename T, int size>
//T factorial()
//{
//    return factorial<T, size-1>*size;
//}

//関数テンプレート、の部分特殊化はできない
//template<typename T>
//T factorial<0>()
//{
//    return 1;
//}

template<typename T, int size>
struct factorial
{
    static T func()
    {
        return factorial<T, size-1>::func() * size;
    }
};

//クラステンプレート、クラステンプレート内テンプレートの部分特殊化は可能
template<typename T>
struct factorial<T, 0>
{
    static T func()
    {
        return 1;
    }
};

int main(void)
{   
    cout << factorial<int, 5>::func();
    return 0;
}

なので、メタプログラミングするんだったら、structを用いてテンプレート化するのが普通。

注)関数のオーバーロードを有効活用すれば、関数の部分特殊化っぽいことは表現可能。
*2

#include <iostream>
using namespace std;


template<int v>
struct Int2Type
{
    //enum { value = v};
    static const int value = v;
};

//実際の実装は、ここらにかく。
template<typename T>
void DoSth_impl(T* pObj, Int2Type<true>)
{
    T* pNewObj = pObj->Clone();
}

template<typename T>
void DoSth_impl(T* pObj, Int2Type<false>)
{
    T* pNewObj = new T(*pObj);
    cout << *pNewObj << endl;
}

//オーバーロードにより、関数の部分特殊化を実現する。
template<typename T, bool isPolyMorphic>
void DoSomething(T* pObj)
{
    DoSth_impl(pObj, Int2Type<isPolyMorphic>());
}

//普通に関数の部分特殊化を以下のように行うと、失敗することに注意。
//template<typename T>
//void DoSomething<false>(T* pObj) { /* Do Sth*/ }

int main(void)
{
    int* p = new int;
    *p = 7;
    DoSomething<int, false>(p);
    
    return 0;
}

昔風に、enumハック*3を用いて、コンパイル時階乗計算:

#include <iostream>
using namespace std;

template<int N>
struct factorial
{
    //enum hack
    enum { value = N * factorial<N - 1>::value };
};

template<>
struct factorial<0>
{
    enum {value = 1 };
};

int main(void)
{
    cout << factorial<4>::value << endl;
    return 0;
}

enumハック使わずに、static constを用いる方法もある。(というより、enum ハックが技巧的)

#include <iostream>
using namespace std;

template<int N>
struct factorial
{
    static const int value = N * factorial<N-1>::value;
};

template<>
struct factorial<0>
{
    static const int value = 1;
};

int main(void)
{
    cout << factorial<4>::value << endl;
    return 0;
}

C++11以降のconstexprを用いた*4コンパイル時階乗計算:

#include <iostream>
using namespace std;

//引数(int n)がコンパイル時にわかっていれば、factorial関数の戻り値はコンパイル時に定数として求められる。
//逆に引数がコンパイル時にわかっていなければ、factorial関数の戻り値は実行時に決定する。
constexpr int factorial(int n)
{
    return n == 0 ? 1 : n*factorial(n-1);
}

int main(void)
{
    int n = 4;
    //実行時計算
    cout << factorial(n) << endl;
    
    //引数が定数 => コンパイル時計算
    cout << factorial(4) << endl;
}

まとめると、値をコンパイル時に計算する場合は、enum, const static, constexprを用いる。
ちなみに、型の変換や型の判別を静的に行う場合は、typedef, usingを用いる。*5

*1:でも、これ、関数の戻り値計算まではコンパイル時に計算してくれるけど、factorial関数から、mainに値を戻す作業は実行時に行うので、厳密な意味ではコンパイル時計算でない

*2:void DoSomethingの第二引数に、Int2Type型を指定しているが、空の構造体のサイズは0ではないので、inlineを指定しない限りは、オーバーヘッドが完全になくなるわけではないと思う。

*3:enum classは、汎整数型として解釈されない。詳しくは Effective Modern C++ ch.10を参照のこと

*4:constexpr関数は必ずしも、constexprの戻り値を返すわけではない。Effective Modern C++ ch.15を参照のこと。

*5:C++11では、usingはtypedefの上位互換である。 http://qiita.com/Linda_pp/items/44a67c64c14cba00eef1とか、Effective Modern C++ 項目9を参照してください

C++ Question

1. 暗黙の型変換について、どれくらい話題を知っているか?

  • 単一の実引数コンストラクタ(explicitつけない)は、暗黙の型変換を引き起こす*1
  • Proxy Class*2
  • operator bool *3
  • 戻り値型の推論*4

2. +=演算子と+演算子を自作クラスでどうオーバーロードするか?

  • テンプレート絡まない場合
  • テンプレート絡む場合

3. C++特有の最適化

  • テンポラリオブジェクトの生成、破棄のタイミング
    • 戻り値最適化(Return Value Optimization : RVO)*5 => これによって、名前付きコンストラクタ(Named Constructor Idiom)が処理速度的に正当化できる。

*1:More Effective C++ ch.5

*2:More Effective C++ ch.5

*3:C++テンプレートテクニック ch.10

*4:C++テンプレートテクニック ch.10

*5:More Effective C++ ch.20

テンプレート引数が複数の場合

C++ template

 クラステンプレートは部分特殊化(partial specialization)できるが、関数テンプレートやメンバ関数テンプレートは部分特殊化できない。

テンプレート 多重定義 部分特殊化 明示的特殊化
クラステンプレート ×
関数テンプレート ×

 部分特殊化よりも多重定義のほうがカバーできる範囲は少ない。
 明示的特殊化と多重定義は被る(template<>プレフィクスをつけてもつけなくても動作が同じ)になる場合がある。

例)

#include <iostream>

template<typename T>
T func(T value)
{
    return value;
}

//関数の多重定義(部分特殊化ではないことに注意。)そもそも、関数テンプレートは部分特殊化できない。
template<typename T>
T func(T* value)
{
    return (*value) * 2;
}

//こっちだと、関数の多重定義
//int func(int value)
//{
//    return 1;
//}

//こっちだと明示的特殊化
template<>
int func(int value)
{
    return value << 2;
}

int main(void)
{
    std::cout << func(3) << std::endl;
    
    int n = 3;
    int* pn = &n;
    std::cout << func(pn) << std::endl;
    
    return 0;
}


 テンプレート引数が複数の場合は、「関数テンプレートやメンバ関数テンプレートは部分特殊化できない」ということに特に気を付ける必要がある。
 一方を明示的に特殊化(下の場合はint sizeの部分)しても、残りのテンプレート(typename Tの部分)が特殊化されていない場合は、部分特殊化であることには変わりがない。結構はまったのでメモ。

template<typename T, int size>
T make_rev(const T init)
{
    return init*size;
}

//関数テンプレートの部分特殊化はできない
//template<typename T>
//T make_rev<T, 0>(const T init)
//{
//    return init;
//}

 こんなことをしたかったら、クラステンプレート(struct)の部分特殊化をすればよい:

#include <iostream>
#include <vector>

template<typename T, int size>
struct Make_rev
{
    static T func(const T init)
    {
        return init*size;
    }
};

//クラステンプレートの部分特殊化は可能
template<typename T>
struct Make_rev<T, 0>
{
    static T func(const T init)
    {
        return init;
    }
};

int main(void)
{   
    std::cout << Make_rev<int, 3>::func(5) << std::endl;
    std::cout << Make_rev<int, 0>::func(5) << std::endl;
    
    return 0;
}

 メンバ関数テンプレートも基本的な考え方は同じ:

#include <iostream>
#include <vector>

template<typename T, int size>
struct Make_rev;

template<typename T>
class Test
{
private:
	T value;     
public:
	Test(T value) : value(value) {}
	~Test() = default;

	template<int size>
		T rev(const T init)
	{
		//sizeのみの部分特殊化を行いたい。
		return Make_rev<T, size>::func(init, value);
	}
};


template<typename T, int size>
struct Make_rev
{
    static T func(const T init, const T value)
    {
        return init*size * value;
    }
};

//クラステンプレートの部分特殊化は可能
template<typename T>
struct Make_rev<T, 0>
{
    static T func(const T init, const T value)
    {
        return init * value;
    }
};

int main(void)
{   
    Test<int> t(7);
    
    std::cout << t.rev<3>(5) << std::endl;
    std::cout << t.rev<0>(5) << std::endl;

    return 0;
}

Visitor pattern

C++ design pattern

Test Visitor pattern
C++のためのAPIデザイン*1 12章を参照にした。

#include <iostream>
#include <vector>
#include <string>
#include <memory>

class ShapeNode;
class TransformNode;

class INodeVisitor
{
public:
    virtual ~INodeVisitor() {}
    virtual void Visit(ShapeNode& node) = 0;
    virtual void Visit(TransformNode& node) = 0;
};

class BaseNode
{
public:
    explicit BaseNode(const std::string& name) : mName(name) {}
    virtual ~BaseNode() {}
    virtual void Accept(INodeVisitor& visitor) = 0;
private:
    std::string mName;
};

class ShapeNode : public BaseNode
{
private:
public:
    explicit ShapeNode(const std::string& name) : BaseNode(name) {}
    void Accept(INodeVisitor& visitor)
    {
        visitor.Visit(*this);
    }
    int GetPolygonCount() const {return 4;}
};

class TransformNode : public BaseNode
{
private:
public:
    explicit TransformNode(const std::string& name) : BaseNode(name) {}
    void Accept(INodeVisitor& visitor)
    {
        visitor.Visit(*this);
    }
};

class SceneGraph
{
private:
    std::vector<BaseNode*> tree;
public:
    SceneGraph() = default;
    ~SceneGraph() = default;
    SceneGraph(const SceneGraph&) = delete;
    const SceneGraph& operator=(const SceneGraph&) = delete;
    void addScene(BaseNode* baseNode)
    {
        tree.push_back(baseNode);
    }
    void Traverse(INodeVisitor& visitor)
    {
        for(const auto& x : tree)
        {
            //MyVisitorクラスに個数カウントメソッドをまとめて、明記した
            x->Accept(visitor);
        }
    }
};

class MyVisitor : public INodeVisitor
{
private:
    int mNumShapes;
    int mNumPolygons;
    int mNumTransforms;
public:
    MyVisitor() : mNumShapes(), mNumPolygons(), mNumTransforms() {}
    void Visit(ShapeNode& node)
    {
        mNumPolygons += node.GetPolygonCount();
        ++mNumShapes;
    }
    
    void Visit(TransformNode&)
    {
        ++mNumTransforms;
    }
    int getNumShapes() {return mNumShapes; }
    int getNumPolygons() {return mNumPolygons; }
    int getNumTransforms() {return mNumTransforms; }
};

void print(MyVisitor& v)
{
    std::cout << "Shapes : " << v.getNumShapes() << std::endl;
    std::cout << "Polygons : " << v.getNumPolygons() << std::endl;
    std::cout << "Transforms : " << v.getNumTransforms() << std::endl;
}

int main(void)
{
    SceneGraph s;
    std::unique_ptr<BaseNode> n1(new ShapeNode("test1"));
    std::unique_ptr<BaseNode> n2(new TransformNode("test2"));
    s.addScene(n1.get());
    s.addScene(n2.get());
    
    MyVisitor visitor;
    s.Traverse(visitor);
    print(visitor);
    return 0;
}