模板元编程 第三章课后练习（非答案）

3-0

template<int N>
struct cal
{
	BOOST_STATIC_ASSERT((N%10>=0));
	BOOST_STATIC_ASSERT((N%10<2));
	static const int val = 2*cal<N/10>::val+N%10;
};

template<>
struct cal<0>
{
	static const int val = 0;
};

3-1，3-2

	BOOST_STATIC_ASSERT((mpl::equal<vector_c<int,2,3,4>,mpl::transform<vector_c<int,1,2,3>,vector_c<int,1,1,1>,plus_f>::type>::type::value));
	BOOST_STATIC_ASSERT((mpl::equal<vector_c<int,1,4,9>,mpl::transform<vector_c<int,1,2,3>,vector_c<int,0,2,6>,plus_f>::type>::type::value));

3-3，3-4其实差不多

template<typename F,typename T>
struct fourtimes:twice<F,typename twice<F,T>::type>{};

3-5

template<typename T,typename D1,typename D2>
quantity<T,D1> operator+(quantity<T,D1> a,quantity<T,D2> b){
	return operator+(a,quantity<T,D1>(b));
}

相关代码

#include<iostream>
#include<vector>
#include<map>
#include<boost\type_traits\is_same.hpp>
#include"test_staticAccert.h"
#include<boost\mpl\lambda.hpp>
#include<boost\mpl\apply.hpp>
#include<boost\mpl\plus.hpp>
#include<boost\mpl\placeholders.hpp>
#include<boost\mpl\vector_c.hpp>
#include<boost\mpl\transform.hpp>
#include<boost\mpl\equal.hpp>
#include<boost\type_traits\add_pointer.hpp>
#include<boost\mpl\apply.hpp>
using namespace std;
using namespace boost;
using namespace mpl::placeholders;
using mpl::vector_c;
typedef mpl::vector_c<int,0,1,-1,0,0,0,0> velocity;
typedef mpl::vector_c<int,0,1,-2,0,0,0,0> acceleration;
typedef mpl::vector_c<int,1,0,0,0,0,0,0> momentum;
typedef mpl::vector_c<int,1,1,-2,0,0,0,0> force;
typedef mpl::vector_c<int,0,1,-1,0,0,0,0> scalar;

typedef mpl::apply<_1,mpl::plus<_1,_2> >::type t2;

struct plus_f{
	template<typename T,typename D>
	struct apply{
		typedef typename mpl::plus<T,D>::type type;
	};
};
struct minus_f{
	template<typename T,typename D>
	struct apply:mpl::minus<T,D>{};
};

template<typename T,typename dimensions>
struct quantity
{
	explicit quantity(T x):m_value(x){}
	T value() const {return m_value;}
	template<typename otherdimensions>
	quantity(quantity<T,otherdimensions> const &x):m_value(x.value()){
		BOOST_STATIC_ASSERT((mpl::equal<dimensions,otherdimensions>::type::value));
	}
private:
	T m_value;
};



template<typename T,typename D>
quantity<T,D> operator+(quantity<T,D> a,quantity<T,D> b){
	return quantity<T,D>(a.value()+b.value());
}
template<typename T,typename D1,typename D2>
quantity<T,D1> operator+(quantity<T,D1> a,quantity<T,D2> b){
	return operator+(a,quantity<T,D1>(b));
}
template<typename T,typename D>
quantity<T,D> operator-(quantity<T,D> a,quantity<T,D> b){
	return quantity<T,D>(a.value()-b.value());
}
template<typename T,typename D1,typename D2>
quantity<T,typename mpl::transform<D1,D2,plus_f>::type> operator*(quantity<T,D1> a,quantity<T,D2> b){
	typedef typename mpl::transform<D1,D2,mpl::plus<_1,_2>>::type type;
	return quantity<T,type>(a.value()*b.value());
}

template<typename F,typename T>
struct twice:F::template apply<typename F::template apply<T>::type>{//转发元函数

};

struct add_pointer_f
{
	
	template<typename T>
	struct apply:boost::add_pointer<T>
	{
		
	};
};

template<typename F,typename T>
struct fourtimes:twice<F,typename twice<F,T>::type>{};



int main(){
	return 0;
}