tags:

views:

630

answers:

8

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?

+27  A: 

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.

Tyler McHenry
You can, however, create a *wrapper* for `sizeof`, which might be what the OP needs. Hard to tell without more context.
JSBangs
ok thanks i understand
His confusion is understandable, since you *can* override new/delete.
BlueRaja - Danny Pflughoeft
Is it possible to write your own version of `return` then?
Pindatjuh
@pindatjuh If you're serious, no. Although much like AndreyT's answer, there are silly tricks that could give the same effect, such as inline assembly or abuse of `setjmp`/`longjmp`.
Tyler McHenry
+1  A: 

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.

Mike Seymour
+20  A: 

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, if 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.

AndreyT
quite stupid homework assignment to wrap sizeof() if you ask me
Viktor Sehr
I thought of the char* hack too. A silly exercise indeed.
Reinderien
Of course the fact that this works is completely dependent on the compile-time invariant `sizeof(char) == 1`, which is a bit of a catch-22.
Tyler McHenry
Well, the size `sizeof` returns is measured in "char sizes", since in C/C++ terminology char is byte and byte is char.
AndreyT
You've done quite a detailed answer. +1 for the heroic efforts and nice results
Johannes Schaub - litb
@AndreyT : The size of `char` is 2 on some systems. This is not a constant defined by C.
kbok
@kbok: Incorrect. In C language `sizeof(char)` is always exactly 1. It *is* a constant defined by C. If on some system `char` occupies more than 1 machine byte, that only means that from C language point of view each C-byte will consist of several machine bytes. And `sizeof(char)` will still be exactly 1. In other words, `sizeof` in C evaluates to the object/type size in `char`s, so no matter what `sizeof(char)` is always 1.
AndreyT
+1, @AndreyT. In C and C++, `char` is always 1 byte. That doesn't mean it's 8 bits, but it *is* always 1 byte, hence `sizeof(char) == 1` is always true.
Carl Norum
+4  A: 

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!

Clifford
A: 

If he wants to write his own sizeof he just needs to grab the source code of a C++ compiler and go ahead. The source will also show how sizeof can be implemented.

Peter G.
It would probably be implemented using compiler-internal data structures that couldn't be accessed via the C++ source.
Mark B
You misunderstood me. My advice was to create a modified compiler from an existing compiler source. This can be very educational.
Peter G.
+4  A: 

A non-portable way to write your own sizeof() function is to take advantage of how stack-based variables are often laid out in memory:

#include <iostream>
using namespace std;

template <typename T>
int mysizeof(T)
{
  T temp1;
  T temp2;

  return (int)&temp1 - (int)&temp2;
}

int main()
{
  cout << "sizeof mysizeof" << endl;

  char c = 0; short s = 0; int i = 0; long l = 0;
  float f = 0; double d = 0; long double ld = 0;

  cout << "char: " << mysizeof(c) << endl;
  cout << "short: " << mysizeof(s) << endl;
  cout << "int: " << mysizeof(i) << endl;
  cout << "long: " << mysizeof(l) << endl;
  cout << "float: " << mysizeof(f) << endl;
  cout << "double: " << mysizeof(d) << endl;
  cout << "long double: " << mysizeof(ld) << endl;
}

See it in action.
A 0-parameter version.
A version that uses one array instead of two variables.

Warning: This was a fun puzzle, but you should never use this in real code. sizeof is guaranteed to work. This is not. Just because it works on this version of this compiler for this platform does not mean it will work for any other.

The real operator takes advantage of being a part of the compiler. Sizeof knows how big each type of variable is because it has to know. If the compiler doesn't know how big each type is, it wouldn't be able to lay your program out in memory.

Edit: Note that all of these flawed examples rely on the original sizeof operator. It's used to space the stack variables, and to create and index array variables.

Bill
It'd probably be safer to have an array of two items, rather than counting on the compiler to put locals in a given order. array[1] always comes after array[0], and with the proper padding.
dash-tom-bang
@dash: I thought about that too, but got distracted. I've updated my answer with a link to an array-based implementation.
Bill
Neither implementation works on an abstract class or a class lacking a public, zero parameter constructor either.
jmucchiello
@jmuc: Good points! I only tested on built-in types, and just for the exercise.
Bill
dash-tom-bang
@dash: That works: http://codepad.org/NgwP4x1A . Of course, array indexing uses sizeof implicitly, but then, so does layout variables in memory.
Bill
A: 

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.

LonliLokli
+2  A: 

sizeof is an C++ operator which yields the number of bytes in the object representation of its operand. Result of sizeof is an implementation-defined constant of type size_t, but should meet the requirements set forth in C++ Standard 5.3.3. You could write your own type traits that will work similar to built-in sizeof operator.

template<typename T> struct get_sizeof;

template<> struct get_sizeof<char>          { static const size_t value = 1; };
template<> struct get_sizeof<unsigned char> { static const size_t value = 1; };
template<> struct get_sizeof<int>           { static const size_t value = 4; };
template<> struct get_sizeof<long>          { static const size_t value = 4; };
// etc.

...
// sample of use
static const size_t size = get_sizeof<int>::value;
char x[get_sizeof<int>::value];

But this have no sense since only creators of the compiler are knows actual values of value for the implementation.

Kirill V. Lyadvinsky