プログラマ専用SNS ミクプラ

コード:

template <typename R, typename... Args>
auto func(R (*)(Args...)) {}

int main(void)
{
    func([](int x, int y) { return x + y; });

    return 0;
}

コード:

#include <iostream>
#include <string>
#include <vector>
#include <tuple>
#include <memory>
#include <type_traits>
#include <functional>
using namespace std;

template<typename... Args>
class Type
{
public:
	static inline auto get() -> std::vector<const std::type_info*>
	{
		std::vector<const std::type_info*> type_list;
		type_list.reserve(std::tuple_size<Tuple_Type>::value);
		get<std::tuple_size<Tuple_Type>::value - 1>(type_list);
		return move(type_list);
	}
private:
	template<std::size_t index>
	static inline void get(std::vector<const std::type_info*>& type_list)
	{
		using Element_Type = typename std::tuple_element<index, Tuple_Type>::type;
		type_list.emplace_back(&typeid(Element_Type));
		get<index - 1>(type_list);
	}
	template<>
	static inline void get<0>(std::vector<const std::type_info*>& type_list)
	{
		using Element_Type = typename std::tuple_element<0, Tuple_Type>::type;
		type_list.emplace_back(&typeid(Element_Type));
	}
	template<>
	static inline void get<-1>(std::vector<const std::type_info*>& type_list)
	{
		type_list.emplace_back(typeid(void).name());
	}
public:
	using Tuple_Type = std::tuple<Args...>;
};

template<typename R, typename ...Args>
auto func(R(*)(Args...)) -> R
{
	cout << "戻値の型：" << typeid(R).name() << "\n"
		 << "引数の型：";
	std::vector<const std::type_info*> v = Type<Args...>::get();
	for (auto type : Type<Args...>::get())
		cout << type->name() << " "; cout << "\n" << endl;
	return 0;
}

template<typename Function_Type>
auto func(Function_Type f) -> decltype(func(f))
{
	return func(f);
}

int main()
{
	func<int(int, int)>([](int x, int y) { return x + y; });
	func<double(float, float, float)>([](float x, float y, float z) -> double { return x / y / z; });
	return 0;
}

コード:

#include <iostream>
using namespace std;

template<typename R, typename ...Args>
auto func(R(*)(Args...)) -> R
{
	cout << typeid(R).name() << endl;
	return 0;
}

using Function_Type = int(int, int);
auto hoge(Function_Type f) -> decltype(func(f))
{
	return func(f);
}

int main()
{
	//func([](int x, int y) { return x + y; });  //template側の仮引数の型が明示されていないため、型の不一致により暗黙の型変換どころかtemplateがインスタンス化できない。
	hoge([](int x, int y) { return x + y; });  //仮引数の型が明示されているため、暗黙の型変換ができる。
	return 0;
}

コード:

#include <iostream>
#include <functional>
#include <thread>
#include <future>
using namespace std;

template<typename Func, typename ...Args>
auto worker(Func&& func, Args&&... args) -> packaged_task<typename result_of<Func(Args...)>::type()>
{
	return packaged_task<typename result_of<Func(Args...)>::type()>(bind(forward<Func>(func), forward<Args>(args)...));
}

int func(int a, int b, int c)
{
	return a * b * c;
}

int main()
{
	auto task1 = worker(func, 1, 2, 3);
	auto f1 = task1.get_future();
	thread(move(task1)).detach();
	cout << f1.get() << endl;

	auto task2 = worker([](int a, int b, int c){ return a * b * c; }, 4, 5, 6);
	auto f2 = task2.get_future();
	thread(move(task2)).detach();
	cout << f2.get() << endl;

	cin.ignore();
}

コード:

#include <tuple>
#include <typeinfo>

template <class F, typename R, typename... ArgTypes> R _getResult(R (F::*)(ArgTypes...));
template <class F, typename R, typename... ArgTypes> R _getResult(R (F::*)(ArgTypes...) const);
template <class F> using getResultType = decltype(_getResult(&F::operator()));

template <class F, typename R, typename... ArgTypes> std::tuple<ArgTypes...> _getArgs(R (F::*)(ArgTypes...));
template <class F, typename R, typename... ArgTypes> std::tuple<ArgTypes...> _getArgs(R (F::*)(ArgTypes...) const);
template <class F> using getArgTypeList = decltype(_getArgs(&F::operator()));

// type_at: 型リストの I 番目の型を取得する

template <size_t, class>
struct _type_at;
template <size_t I, typename Head, typename... Tail>
struct _type_at<I, std::tuple<Head, Tail...>> : _type_at<I - 1, std::tuple<Tail...>> {};
template <typename Head, typename... Tail>
struct _type_at<0, std::tuple<Head, Tail...>> { using type = Head; };

template <size_t I, class TypeList>
using type_at = typename _type_at<I, TypeList>::type;

// ラムダ式の戻り値の型の名前を返す
template <class F>
auto getResultTypeName(F f)
{
	return typeid(getResultType<F>).name();
}

// ラムダ式の I 番目の引数の型の名前を返す
template <size_t I, class F>
auto getArgTypeName(F f)
{
	return typeid(type_at<I, getArgTypeList<F>>).name();
}

int main(void)
{
	auto f = [](int x, float y) -> double { return x * y; };

	getResultTypeName(f); // double
	getArgTypeName<0>(f); // int
	getArgTypeName<1>(f); // float

	return 0;
}

コード:

#include <iostream>
#include <string>
#include <tuple>
#include <typeinfo>

template <typename R, typename... Args> auto getResultType(R(*)(Args...)) -> R;
template <typename F, typename R, typename... Args> auto getResultType(R(F::*)(Args...)) -> R;
template <typename F, typename R, typename... Args> auto getResultType(R(F::*)(Args...) const) -> R;
template <typename F, typename R = decltype(getResultType(&F::operator()))> auto getResultType(F) -> R;
#define Result_Type(f) decltype(getResultType(f))

template <std::size_t I, typename R, typename... Args> auto getArgsType(R(*)(Args...)) -> typename std::tuple_element<I, typename std::conditional<std::is_same<std::tuple<Args...>, std::tuple<>>::value, std::tuple<void>, std::tuple<Args...>>::type>::type;
template <std::size_t I, typename F, typename R, typename... Args> auto getArgsType(R(F::*)(Args...)) -> typename std::tuple_element<I, typename std::conditional<std::is_same<std::tuple<Args...>, std::tuple<>>::value, std::tuple<void>, std::tuple<Args...>>::type>::type;
template <std::size_t I, typename F, typename R, typename... Args> auto getArgsType(R(F::*)(Args...) const) -> typename std::tuple_element<I, typename std::conditional<std::is_same<std::tuple<Args...>, std::tuple<>>::value, std::tuple<void>, std::tuple<Args...>>::type>::type;
template <std::size_t I, typename F, typename R = decltype(getArgsType<I>(&F::operator()))> auto getArgsType(F) -> R;
#define Args_Type(i,f) decltype(getArgsType<i>(f))

int main()
{
	auto f = [](int, double, std::string) { return "abc"; };

	//ラムダ式から取り出した仮引数の型で、変数を宣言する。
	Result_Type(f) r = "address";
	Args_Type(0,f) a = 2;
	Args_Type(1,f) b = 10.08;
	Args_Type(2,f) c = "hello";

	std::cout << "[](int, double, std::string) { return \"abc\"; }" << std::endl;
	std::cout.width(9); std::cout << r << ": "; std::cout << typeid(r).name() << std::endl;
	std::cout.width(9); std::cout << a << ": "; std::cout << typeid(a).name() << std::endl;
	std::cout.width(9); std::cout << b << ": "; std::cout << typeid(b).name() << std::endl;
	std::cout.width(9); std::cout << c << ": "; std::cout << typeid(c).name() << std::endl;
	std::cout << std::endl;


	//別のラムダ式から取り出した仮引数の型で、新しいラムダ式の仮引数の型を構成する。
	auto f2 = [](Args_Type(1, f) x, Args_Type(0, f) y) { return x / y; };

	std::cout << "[](Args_Type(1, f) x, Args_Type(0, f) y) { return x / y; }" << std::endl;
	std::cout.width(9); std::cout << f2(b, a) << ": "; std::cout << typeid(Result_Type(f2)).name() << std::endl;

	std::cin.ignore();
	return 0;
}

コード:

template <class T, typename... Args, class F,
	class = std::enable_if_t<std::is_convertible<F, T>::value>>
T toFuncPtr(F &&f) // キャプチャしないラムダ式
{
	return f;
}

template <class T, typename... Args, class F,
	class = std::enable_if_t<!std::is_convertible<F, T>::value>>
T toFuncPtr(F f) // キャプチャするラムダ式
{
	static F l = std::forward<F>(f);

	return [](Args... args)
	{
		// 今回は戻り値の型がvoidの時を考慮していない
		return l(std::forward<Args>(args)...);
	};
}

template <class F, size_t... I>
auto toFuncPtr(F &&f, std::index_sequence<I...>)
{
	using func_ptr_t = getResultType<F> (*)(type_at<I, getArgTypeList<F>>...);
	return toFuncPtr<func_ptr_t, type_at<I, getArgTypeList<F>>...>(std::forward<F>(f));
}

template <class F>
auto toFuncPtr(F &&f)
{
	return toFuncPtr(std::forward<F>(f), std::make_index_sequence<std::tuple_size<getArgTypeList<F>>::value>{});
}

コード:

int v = 5;

auto a = [](){};
auto b = [](){};
auto c = [=](){};
auto d = [&](){};

コード:

using F = void (*)(void);
operator F() const;

コード:

int x = 0;
auto f = [&] { return x; };

コード:

int x = 0;

class closure_object
{
public:
	closure_object(int &x) : x(x) {}

	int operator ()(void) { return x; }

private:
	int &x;
} f(x);