C++之std::declval的具体使用

template <class _Ty>
add_rvalue_reference_t<_Ty> declval() noexcept;

//调用引用限定符修饰的成员函数
class ALR
{
public:
	void onAnyValue()
	{
		qDebug() << "ALR::onAnyValue()函数执行了！" << endl;
	}

	void onLvalue()& //只能被类ALR的左值对象调用
	{
		qDebug() << "ALR::onLvalue()函数执行了！" << endl;
	}

	void onRvalue()&& //只能被类ALR的右值对象调用
	{
		qDebug() << "ALR::onRvalue()函数执行了！" << endl;
	}
};

template <typename T>
T&& mydeclval() noexcept;

int main() {
	ALR alr;  //左值对象alr
	alr.onLvalue();
	//alr.onRvalue(); //编译错误，因为onRvalue只能被类A的右值对象调用
	ALR().onRvalue();  //临时对象是右值对象
	//ALR().onLvalue();  //编译错误，因为onLvalue只能被类A的左值对象调用

	decltype(mydeclval<ALR>().onAnyValue());
	decltype(mydeclval<ALR&>().onLvalue()); //返回的 类型是class ALR &，代表返回的是左值对象，左值对象调用onLvalue没问题
	decltype(mydeclval<ALR&&>().onRvalue()); //返回的 类型是class ALR &&，代表返回的是右值对象，右值对象调用onRvalue没问题
	//decltype(mydeclval<ALR&>().onRvalue());//返回的 类型是class ALR &，代表返回的是左值对象，左值对象调用onRvalue是错误的
	//decltype(mydeclval<ALR&&>().onLvalue()); //返回的 类型是class ALR &&，代表返回的是右值对象，右值对象调用onLvalue是错误的
    return 0;
}

template <typename T>
class CMessageEntityManagerTemplate
{
    //方法1
    //using KEY = decltype(((T*)0)->id());
    //方法3
    using KEY = decltype(std::declval<T>().id());
    ...
    ...
}

#include <utility>
#include <iostream>
 
struct Default { int foo() const { return 1; } };
 
struct NonDefault
{
    NonDefault() = delete;
    int foo() const { return 1; }
};
 
int main()
{
    decltype(Default().foo()) n1 = 1;                   // n1 的类型是 int
//  decltype(NonDefault().foo()) n2 = n1;               // 错误：无默认构造函数
    decltype(std::declval<NonDefault>().foo()) n2 = n1; // n2 的类型是 int
    std::cout << "n1 = " << n1 << '\n'
              << "n2 = " << n2 << '\n';
    return 0;
}

//判断类是否具有某个静态函数
#define HAS_MEMBER_EX(member)\
template<typename T, typename... Args> struct has_member_ex_##member{\
private:\
    template<typename U> \
	static auto Check(int) -> decltype(U::member(std::declval<Args>()...), std::true_type()); \
	template<typename U> \
	static std::false_type Check(...); \
public:\
	enum { value = std::is_same<decltype(Check<T>(0)), std::true_type>::value }; \
}; \

HAS_MEMBER_EX(getDataSize)

//判断类是否具有某个非静态成员函数
#define HAS_NON_STATIC_MEMBER_EX(member)\
template<typename T, typename... Args> struct has_non_static_member_ex_##member{\
private:\
    template<typename U> \
	static auto Check(int) -> decltype(std::declval<T>().member(std::declval<Args>()...), std::true_type()); \
	template<typename U> \
	static std::false_type Check(...); \
public:\
	enum { value = std::is_same<decltype(Check<T>(0)), std::true_type>::value }; \
}; \

HAS_NON_STATIC_MEMBER_EX(getDataSize)

using PUInt32 = unsigned int;
using PUInt16 = unsigned short;

//参数配置
struct stParamConfig
{
	PUInt32  rate;
	PUInt32  speed;
	//...
public:
	static PUInt16 getDataSize() {
		return 10;
	}
};

//业务数据
struct stAppData
{
	char           data[1024];
	PUInt32        size;
	//...
public:
	PUInt32 getDataSize() const {
		return size;
	}
};

//数据包的结构体
struct stShortWavePacket
{
	//...
	void* pAppData;
	//...
};

/*组包功能：获取stType长度, 适应不同的结构体的取长度函数
  stType类型有：1)  stParamConfig
			   2)  stAppData
			   3)  int, double等简单数据结构类型
*/
template <PUInt32 type, typename stType>
int  encodeCommonCmdData(char* data, int len, const stShortWavePacket* pPacket)
{
	//...
	const stType* pAppType = static_cast<const stType*>(pPacket->pAppData);
	assert(pAppType);
	//...

	PUInt32 len = 0;
	if constexpr (has_member_ex_getDataSize<stType>::value) {
		len = stType::getDataSize();
	}
	else if constexpr (has_non_static_member_ex_getDataSize<stType>::value) {
		len = pAppType->getDataSize();
	}
	else {
		len = sizeof(stType);
	}

	//...

	return 1;
}