How does sizeof work? How can I write my own?

Question

I know C++ and know the function sizeof itself but I need to write my own sizeof function so please explain how it works exactly? What does it do with the parameter

Answer 1

sizeof is evaluated at compile-time (Boost and Loki make use of it). So, I think, it is impossible to write sizeof - complain function for dynamically allocated buffer.

Answer 2

sizeof is a compiler built-in operator. It is evaluated at compile-time by the compiler, and there is no runtime code behind it. You cannot write your own.

Asking this is akin to asking how you would write your own version of return.

Answer 3

As already said it is an operator not a function, but additionally it is one of the operators for which operator overloading is not allowed:

Bjarne Stroustrup's C++ Style and Technique FAQ: Why can't I overload dot, ::, sizeof, etc.?

I can think of no conceivable reason why you would want to overload this in any case. If you have an class for which size information other than that which sizeof yields is required, then simply add a member function to provide that information; as for example in std::string:size() which returns the length of the string managed by the object rather than the size of the object which is semantically different; you do not want to monkey with the semantics of sizeof!

Answer 4

sizeof isn't a function. It's an operator in C. We can implement its functionality something like follows.

#include <stdio.h>

#define mysizeof(X)  \

           ({                    \
                  __typeof(X) x;  \
                  (char *) (&x+1) - (char*) (&x); \
           })
int main()
{

     struct sample
     {
         int a;float b; char c;
     };

     printf("%d", mysizeof(struct sample));
     return 0;
}

Answer : 12

Answer 5

You haven't provided any meaningful details about what it is you want to do, so it is hard to figure out what you need.

You can "wrap" sizeof by you own template function like

template <typename T> size_t my_sizeof() {
  return sizeof(T);
}

and then use it as

size_t s = my_sizeof<int>();

From time to time one can come across a request to implement sizeof-like functionality without using sizeof. Requests like that make no practical sense whatsoever, yet sometimes are used as homework assignments. One can probably do it as follows

template <typename T> size_t my_sizeof() {
  T t;
  return (char *) (&t + 1) - (char *) &t;
}

which would require a default-constructible T. A less restricting but formally illegal solution (a hack) would be something like

template <typename T> size_t my_sizeof() {
  return (char *) ((T *) NULL + 1) - (char *) (T *) NULL;
}

The above implementations implement type-based sizeof.

An attempt to emulate the functionality of value-based sizeof might look as follows

template <typename T> size_t my_sizeof(const T& obj) { 
  return my_sizeof<T>();
}

but this will not be even remotely equivalent to the built-in sizeof, at least because the built-in sizeof does not evaluate its argument.

Finally, neither of these implementations will produce integral constant expressions (ICE), as the built-in sizeof does. Producing an ICE that way is impossible to achieve in the current version of the language.

In any case this all, of course, is totally devoid of any practical value. Just use sizeof when you want to know the size.

Answer 6

sizeof isn't a function, and you can't write your own version. The compiler works out the type of the argument (unless it's already a type), then substitutes the expression with an integer constant.