Hi!

Is there an easy way to get the size in bytes of an intricate user-
defined type even if there is not yet a variable of this type?

Something like:

INTEGER, PARAMETER :: NMax = 10

TYPE MyType
INTEGER(2), DIMENSION(NMax) :: Values
END TYPE MyType

NBytes = SIZEOF(MyType)

which would yield NBytes = 20

My program protests that I want to allocate too much space and I want
to find out how much I was trying to allocate.

Regards,

Arjan

Arjan wrote:
...

...

...

What about allocating one (or a small number) and extrapolating from
there as a kludge?

I'm not sure about the SIZEOF() intrinsic

Arjan wrote:

...

Certainly not in the standard, and I sort of doubt even most of the
usual extensions. There are various ways to get the size of a data
object, but not just of a type itself. You don't tend to be able to use
a type name as an argument (as in your example).

As soon as you declare a variable of the type, then that's a different
story; several potential ways then, standard and extensions, but I'm
under the impression that you know about them.

Apparently not, Richard, please give me some hints!

By the way: I believe that in Pascal the SIZEOF function works with
just a TYPE as arguement.
But then: fortran .NEQ. Pascal...

A.

Arjan wrote:
(snip)

In C, the sizeof operator (not function) works with either
types or variables. Often parentheses are needed, but it
still isn't a function.

-- glen

glen herrmannsfeldt wrote:

Of course, the distinction is hard to follow without formal
definitions of the terms. In most language semantics discussions,
an operator is just syntactic sugar for a function application.

I've got a copy of the C89 rationale document around here
somewhere. I'm not sure it ever stated *why* sizeof is
considered an operator. Though it may be that they wanted
to allow types as operands, and didn't want to special-case
their description of functions.

James Giles wrote:
(snip on sizeof function or operator)

Mostly that the parenthesis needed for a function call
aren't needed for sizeof.

Function call is also an operator. You can apply () to
anything of the appropriate type, even the return value
from a function. (Not that I have ever tried the latter.)

I usually do. sizeof(struct xyz), sizeof(long double),
sizeof(a+b).

Arjan wrote:

Oh, I thought your emphasis on using the type without declaring a
variable meant that you knew those ways. Well, lets' see...

1. In f2003, oh, hold on. That's right - that one didn't make it into
f2003. One of my pet peeves that f2003 added new features that applied
only to f77-style stuff. (You could get the size of the f77 kinds, but
that's all). Anyway, the f2008 draft has a storage_size intrinsic. Some
compilers might implement it already, as it is trivial. I think the
f2008 draft also has C_SIZEOF (or some such name), though it is
basically redundant with storage_size.

2. Lots of compilers today have extensions, often called sizeof.

3. The best you can do that is standard conforming today is to use

inquire (iolength=result_variable) data_variable

Richard Maine wrote:

Gary Scott sbcglobal.net> wrote:

I probably wrote it a bit messily, making it harder than it ought to be,
but you might want to reread my prior posting. If you want the Fortran
size of something, you use the intrinsic that is there for exactly that.
It is named storage_size. There are reasons why it is not named sizeof,
but that doesn't sound like what you are complaining about. Sounds like
you are complaining that it doesn't exist in the more general form. It
does. Yes, I very much can come up with non-C-related uses for
storage_size; that's why I proposed it.