Frederick said:
(e-mail address removed) posted:
(1) The first member of a POD has the same address as the POD itself.
(2) There's no padding between array elements.
So alignment isn't a problem.
If you're not allowed to create a temporary, then I think the following
is the closest thing you could have to "sizeof" for a type:
#define sizeof(T) \
(char const *)( ((T) const *)32 + 1 ) \
-(char const *)( ((T) const *)32 ) \
Of course, that isn't legal because you're performing pointer arithmetic
on an invalid pointer value. Also, the result isn't an integral constant
expression, so can't be used as, e.g., an array bound.
If, however, you want the size of an object, or perhaps the size of a
type (but you can use a temporary), then it's trivial:
#include <iostream>
#include <cstddef>
template<class T>
std::size_t SizeOf( T const &obj = T() )
{
return (char const *)(&obj + 1) - (char const *)(&obj);
}
int main()
{
unsigned i;
std::cout << SizeOf(i);
std::cout << SizeOf<unsigned>();
}
Doesn't work for:
1. Non-default constructibles
2. Abstract classes
3. Arrays
4. Other non-copyables
5. References
6. Local types
Here's my version that fixes 1-5, but has other problems (only works up
to a certain type size).
#include <iostream>
#include <cstddef>
std::size_t const biggerThanAnyType = 10000000;
char largeStorage[biggerThanAnyType];
void* const largeStorageP = largeStorage;
template <class T>
struct SizeOf
{
static std::size_t value()
{
return f();
}
private:
static std::size_t f( T const *obj = static_cast<T const*>(largeStorageP))
{
void const* p1 = obj;
void const* p2 = obj + 1;
return static_cast<char const*>(p2) - static_cast<char const*>(p1);
}
};
template <class T, std::size_t N>
struct SizeOf<T[N]>
{
static std::size_t value()
{
return N * SizeOf<T>::value();
}
};
template <class T>
struct SizeOf<T&>
{
static std::size_t value()
{
return SizeOf<T>::value();
}
};
struct Abstract
{
virtual void f() = 0;
};
#define SizeOf(T) (SizeOf<T>::value())
int main()
{
std::cout << SizeOf(int) << '\n';
typedef int array[10][20];
std::cout << SizeOf(array) << '\n';
std::cout << SizeOf(Abstract) << '\n';
std::cout << SizeOf(double&) << '\n';
}
I think it's standards conforming, though I'm happy for someone to pick
it apart.
Tom
