implementing sizeof

[junky_fellow]

Hi,

Is it possible to implement sizeof as a C function ?

[junky_fellow]

Gordon Burditt wrote:

Hi,

Is it possible to implement sizeof as a C function ?

sizeof is defined as an operator; hence it can't be implemented as a
function.

I don't agree with your explanation completely. "*", "-" are
arithmetic operators, but they can be implemented as a function.

How does one implement + as *A* function that takes pointer+integer ,
integer+integer , double+integer, or double+double arguments? And
returns pointer, integer, or double results?

I didn't mean to say, that there won't be any "+" operator at all. What
I wanted to ask that although we have a sizeof,+,-,* etc as operators,
but can we somehow implement them using a function?
In case, "+" is implemented as a ADD() function, then we can't use
pointer+pointer as arguments. In that case, pointer+pointer should be
evaluated by calling function ADD(). function.

[santosh]

ju**********@ya hoo.co.in wrote:

santosh wrote:

ju**********@ya hoo.co.in wrote:

Hi,
>
Is it possible to implement sizeof as a C function ?

sizeof is defined as an operator; hence it can't be implemented as a
function.

I don't agree with your explanation completely. "*", "-" are
arithmetic operators, but they can be implemented as a function.

Well, as Richard pointed out, sizeof must accept types. A function
can't accept a type. It can only accept an object of that type.
Moreover, without using extensions, how can you know the size of the
fundamental types? They're a part of the implementation, thus your
function has to be a part of the implementation too.

Moreover, sizeof is used during compilation. A function you write can't
execute during compilation. I'm sure there're other ceavets that
prevent a function from completely replacing sizeof. If it could, we
probably wouldn't be having sizeof as a part of the language.

[Ian Collins]

ju**********@ya hoo.co.in wrote:

Gordon Burditt wrote:

>>>>>Hi,
>
Is it possible to implement sizeof as a C function ?

sizeof is defined as an operator; hence it can't be implemented as a
function.

I don't agree with your explanation completely. "*", "-" are
arithmetic operators, but they can be implemented as a function.

How does one implement + as *A* function that takes pointer+integer ,
integer+integ er, double+integer, or double+double arguments? And
returns pointer, integer, or double results?

I didn't mean to say, that there won't be any "+" operator at all. What
I wanted to ask that although we have a sizeof,+,-,* etc as operators,
but can we somehow implement them using a function?
In case, "+" is implemented as a ADD() function, then we can't use
pointer+pointer as arguments. In that case, pointer+pointer should be
evaluated by calling function ADD(). function.

You appear to have answered your own question, you can't write a generic
function in C, to do that requites either function overloading, or some
form of generics/templates which C does not have.

So you would either have to write a sizeof function of each type, which
defeats the object, or use another language.

--
Ian Collins.

[junky_fellow]

Peter Nilsson wrote:

ju**********@ya hoo.co.in wrote:

Sharath wrote:

ju**********@ya hoo.co.in wrote:
Hi,

Is it possible to implement sizeof as a C function ?
>
Not completely, but you can implement part of it. Read:
http://prokutfaq.byethost15.com/FindSizeWithoutSizeof
This really is of no use in practice because sizeof is part of
standard. The methods described in that article is not fully portable,
and has its limitations as Richard pointed out.

The link that you pointed seems to have an interesting way of
implementing sizeof. As per the link, the sizeof may be implemented as
follows:

size_t size_obj = (char*)(&obj + 1) - (char*)(&obj);

But, as per C standard, while subtracting two pointers, both should
point to elements of same array object or one past the last element of
the array object.
In the above statement, the pointers need not belong to the same array
object.

A pointer to a single object can be treated as a pointer to an array of
1
element. [6.5.6p7]

However, my question is that, under what conditions this
statement would fail ?

Only if the object were bigger than PTRDIFF_MAX bytes.
[Note that PTRDIFF_MAX is typically smaller than SIZE_MAX.]

Thanks Peter, for telling this.

It can fail if obj has an incomplete type, but then sizeof would fail
too.

Are you sure that sizeof would also fail, becuase as you pointed out
that PTRDIFF_MAX is typically smaller than SIZE_MAX.
Note: sizeof operator uses the type size_t to return the result.

[trm]

ju**********@ya hoo.co.in schrieb:

Peter Nilsson wrote:

ju**********@ya hoo.co.in wrote:

Sharath wrote:
ju**********@ya hoo.co.in wrote:
Is it possible to implement sizeof as a C function ?

Not completely, but you can implement part of it. Read:
http://prokutfaq.byethost15.com/FindSizeWithoutSizeof

[...]

The link that you pointed seems to have an interesting way
of implementing sizeof. As per the link, the sizeof may be
implemented as follows:
>
size_t size_obj = (char*)(&obj + 1) - (char*)(&obj);

[...]

However, my question is that, under what conditions this
statement would fail ?

Only if the object were bigger than PTRDIFF_MAX bytes.
[Note that PTRDIFF_MAX is typically smaller than SIZE_MAX.]

It can fail if obj has an incomplete type, but then sizeof
would fail too.

Are you sure that sizeof would also fail, becuase as you pointed
out that PTRDIFF_MAX is typically smaller than SIZE_MAX.
Note: sizeof operator uses the type size_t to return the result.

That's not relevent; he meant something like the following:

struct foo;
size_t foo_size = sizeof(struct foo);

Without a complete definition of struct foo, that can't compile.

[Richard Bos]

"santosh" <sa*********@gm ail.comwrote:

ju**********@ya hoo.co.in wrote:

santosh wrote:

ju**********@ya hoo.co.in wrote:
Is it possible to implement sizeof as a C function ?
>
sizeof is defined as an operator; hence it can't be implemented as a
function.

I don't agree with your explanation completely. "*", "-" are
arithmetic operators, but they can be implemented as a function.

Well, as Richard pointed out, sizeof must accept types. A function
can't accept a type. It can only accept an object of that type.
Moreover, without using extensions, how can you know the size of the
fundamental types? They're a part of the implementation, thus your
function has to be a part of the implementation too.

Of an object, (char *)(&object+1) - (char *)&object will give you the
size of that object. If you _could_ pass types to functions, you could
declare one object of that type and reduce to the previous problem.

Moreover, sizeof is used during compilation.

That's the other fundamental technical problem. Relatedly, a function
call is never constant expression, so you can't, for example, declare
unsigned char buffer[sizeof_function (object) * number], which you can do
with sizeof.

Richard