使用SFINAE计算不同元素的大小

简介

我刚刚开始阅读和研究SFINAE。为了提高我的理解力，我开始自己尝试。

因此，我一直想知道一种有用但简单的方法来使用SFINAE强大的技巧，我最终考虑了一组函数，这些函数可以计算给定类型占用多少字节;只要我们处理简单类型，解决方案就很简单：

template <typename T> size_t SizeOf(const T &t)
{
return sizeof(T);
};

这种朴素近似将得到任何东西的大小：1 表示char，可能 4 表示int，希望 4 表示char[4]以及任何用于class PrettyAwesome或struct AmazingStuff包括填充字节。但是，此类型管理的动态内存呢？

所以我会检查给定的类型是否是指针类型，那么总大小将是指针的大小加上指向内存的大小(如果有的话)。

template <typename T> size_t SizeOf(const T &*t)
{
size_t Result = sizeof(t);
if (t)
{
Result += sizeof(T);
}
return Result;
};

是的，在这一点上，似乎根本不需要SFINAE，但是，让我们考虑一下容器。容器SizeOf必须是sizeof(container_type)的总和加上其每个元素的大小之和，这是SFINAE输入的地方：

template <typename T> size_t SizeOf(const T &t)
{
size_t Result = sizeof(t);
for (T::const_iterator i = t.begin(); i != t.end(); ++i)
{
Result += SizeOf(*i);
}
return Result;
};

在上面的代码中，检测 tyeT类型是否需要const_iterator，并且容器是地图，也需要对的专用化。

问题

最后，问题从这里开始：我尝试了什么，遇到了什么问题？

#include <type_traits>
#include <string>
#include <map>
#include <iostream>
#include <vector>
// Iterable class detector
template <typename T> class is_iterable
{
template <typename U> static char has_iterator(typename U::const_iterator *);
template <typename U> static long has_iterator(...);
public:
enum
{
value = (sizeof(has_iterator<T>(0)) == sizeof(char))
};
};
// Pair class detector
template <typename T> class is_pair
{
template <typename U> static char has_first(typename U::first_type *);
template <typename U> static long has_first(...);
template <typename U> static char has_second(typename U::second_type *);
template <typename U> static long has_second(...);
public:
enum
{
value = (sizeof(has_first<T>(0)) == sizeof(char)) && (sizeof(has_second<T>(0)) == sizeof(char))
};
};
// Pointer specialization.
template <typename T> typename std::enable_if<std::is_pointer<T>::value, size_t>::type SizeOf(const T &aValue)
{
size_t Result = sizeof(aValue);
if (aValue)
{
Result += sizeof(T);
}
return Result;
}
// Iterable class specialization.
template <typename T> typename std::enable_if<is_iterable<T>::value, size_t>::type SizeOf(const T &aValue)
{
size_t Result = sizeof(aValue);
for (T::const_iterator I = aValue.begin(); I != aValue.end(); ++I)
{
Result += SizeOf(*I);
}
return Result;
}
// Pair specialization.
template <typename T> typename std::enable_if<is_pair<T>::value, size_t>::type SizeOf(const T &aValue)
{
return SizeOf(aValue.first) + SizeOf(aValue.second);
}
// Array specialization.
template <typename T> typename std::enable_if<std::is_array<T>::value, size_t>::type SizeOf(const T &aValue)
{
size_t Result = sizeof(aValue);
for (T *I = std::begin(aValue); I != std::end(aValue); ++I)
{
SizeOf(*I);
}
return Result;
}
// Other types.
template <typename T> typename std::enable_if<std::is_pod<T>::value, size_t>::type SizeOf(const T &aValue)
{
return sizeof(aValue);
}
int main(int argc, char **argv)
{
int Int;
int *IntPtr = &Int;
int twoints[2] = {0, 0};
int *twointpointers[2] = {IntPtr};
std::string SO("StackOverflow");
std::wstring WSO(L"StackOverflow");
std::map<std::string, char> m;
std::vector<float> vf;
m[SO] = 'a';
std::cout << "1: " << SizeOf(Int) << 'n';
// std::cout << "2: " << SizeOf(IntPtr) << 'n';
// std::cout << "3: " << SizeOf(twoints) << 'n';
// std::cout << "4: " << SizeOf(twointpointers) << 'n';
std::cout << "5: " << SizeOf(SO) << 'n';
std::cout << "6: " << SizeOf(WSO) << 'n';
std::cout << "7: " << SizeOf(m) << 'n';
std::cout << "8: " << SizeOf(vf) << 'n';
return 0;
}

上面的代码生成此输出：

1: 4
5: 45
6: 58
7: 66
8: 20

1. 如果我取消注释带有 2、3 和 4 输出的行，编译器将显示">不明确的调用"错误。我真的以为输出 2 将使用is_pointer专用化，输出 3 和 4 将使用is_array专用化。好吧，我错了，但我不知道为什么。

2. 我对获取容器总大小的方式不满意，我认为迭代所有项目并为每个项目调用SizeOf是一个不错的选择，但不适用于所有容器，std::basic_string做sizeof(container) + sizeof(container::value_type) * container.size()会更快，但我无法意识到如何专注于basic_string。

谈到检测类

3. (如检测可迭代和配对的类)，在一些关于SFINAE的博客文章和网络示例中，我看到这是一种常见的做法，创建一个true_type和false_typetypedefs，通常定义为char和char[2];但我发现一些作者使用char和long作为true_type和false_type。有人知道一个是最佳实践还是最标准的做法？

请注意，我不是在寻找诸如为什么不尝试"这个库"或"这个工具">之类的答案，我的目标是练习和理解SFINAE，任何线索和建议都是好的。