Effective C++: std::invoke_result

2019独角兽企业重金招聘Python工程师标准>>>

#include <iostream>
#include <type_traits>

int function(const int& number)
{
	std::cout<< number <<std::endl;
	return number;
}

struct CallObject{
	
	inline CallObject(const int& val){}
	
	template<typename T>
	inline T operator()(const T& value)noexcept
	{
		return value;
	}
};

struct CObject{
	int data;
	
	inline CObject(const int& val):data(val){}
	
	inline int getData(const int& number)noexcept
	{
		return (this->data);
	}
};

int main()
{
	
	//case 0:
	std::cout<< std::boolalpha
	         << std::is_same<int(const int&), decltype(function)>::value <<std::endl; //注意function并没有转为指针. 
	
	//case 1:
	std::cout<< std::is_same<int(*)(const int&), decltype(&function)>::value <<'\n'
	         << std::is_same<int, std::invoke_result<decltype(&function)(const int&)>::type>::value <<std::endl;
	         
	//case 2:
	std::cout<< std::is_same<int(&)(const int&), decltype(function)&>::value <<'\n'
	         << std::is_same<int, std::invoke_result<decltype(function)& (const int&)>::type>::value <<std::endl;
	
	//case 4:
	std::cout<< std::is_same<int(*)(const int&), decltype(function)*>::value <<'\n'
	         << std::is_same<int, std::invoke_result<decltype(function)* (const int&)>::type>::value <<std::endl;
	
	//case 5:
	std::cout<< std::is_same<int, std::invoke_result<CallObject(const int&)>::type>::value <<std::endl; //ok,可以看出构造函数并不造成影响.
	
	//case 6:
	std::cout<< std::is_same<int, decltype(std::declval<CObject>().getData(std::declval<const int&>()))>::value <<std::endl;
	
	//case 7:
	std::cout<< std::is_same<int, decltype(std::declval<CObject>().data)>::value <<std::endl;

        //case 8:
       std::cout<< std::is_same<int, std::invoke_result<decltype(&CObject::getData)(CObject, const int&)>::type>::value <<std::endl;
	
	
	return 0;
}

 

std::declval

template<class T>
typename std::add_rvalue_reference<T>::type declval();

转换任何类型T到右值引用类型(rvalue-reference)，可以让我们通过decltype推断成员函数的返回类型，而不需要通过构造函数（既不需要默认构造函数，也不需要我们定义的函数)。

看一段代码吧:

#include <utility>
#include <iostream>
 
struct Default { int foo() const { return 1; } };
 
struct NonDefault
{
    NonDefault(const NonDefault&) { } //这里我们定义了构造函数，而没有定义默认构造函数
                                      //编译器不会再合成默认构造函数.
    int foo() const { return 1; }
};
 
int main()
{
    decltype(Default().foo()) n1 = 1;                   // type of n1 is int
//  decltype(NonDefault().foo()) n2 = n1;               // error: no default constructor
    decltype(std::declval<NonDefault>().foo()) n2 = n1; // type of n2 is int
    std::cout << "n1 = " << n1 << '\n'
              << "n2 = " << n2 << '\n';
}

 

Demo:

关于成员函数的一点解惑.

#include <iostream>
#include <functional>
#include <string>
#include <type_traits>


template<typename T>
class Node {
public:
	Node() = default;
	Node(const T& val) :value(val) {}
	Node(const Node<T>& other) :value(other.val) {}
	Node<T>& operator=(const Node<T>& other);

	int print()const;

private:
	T value;
};

template<typename T>
Node<T>& Node<T>::operator=(const Node<T>& other)
{
	this->value = other.value;

	return *this;
}

template<typename T>
int Node<T>::print()const
{
	std::cout << this->value << std::endl;

	return 10l;
}

template<typename T, typename Class>
void function(T Class::* func)
{
	std::cout << std::boolalpha;
	std::cout << std::is_same<int()const, T>::value << std::endl; //注意这里.
}

int main()
{
	Node<int> node{ 20 };
	function(&Node<int>::print);

	return 0;
}

 

转载于:https://my.oschina.net/SHIHUAMarryMe/blog/693934