Re: Variant

From:

=?Utf-8?B?Rmls?= <Fil@discussions.microsoft.com>

Newsgroups:

microsoft.public.vc.language

Date:

Wed, 28 May 2008 11:06:01 -0700

Message-ID:

<D1A3DB2F-4550-40D0-83CF-EB2207A93438@microsoft.com>

Oh, I didn't expect it to work.
I tried the below:

---------------------------------------------------------------------------

#include <iostream>
using namespace std;

int varSize(int variable)
{
    int * pointer;
    int * oldPointer;
    pointer=&variable;
    oldPointer=pointer;
    pointer++;
    return (int)pointer - (int)oldPointer;
}

void main(void)
{
    char c;
    short s;
    int i;
    double d;
    cout << varSize(c) << endl ;
    cout << varSize(s) << endl ;
    cout << varSize(i) << endl ;
    cout << varSize(d) << endl ;

    system("Pause");
}

---------------------------------------------------------------------------

I would have expected compiling errors because I am passing variables which
aren't of the expected type. But it works. Does that mean that char, short
and double types are converted to int type before entering the function? What
if I initialize my double to a value that doesn't fit in the int range of
values? I'll try.

I think I have to train a little bit before I can possibly understand the
rest of your message.

Thanks

"Tim Roberts" wrote:

Fil <Fil@discussions.microsoft.com> wrote:

I am currently learning C++ and I am trying to make a function that would
take a parameter and tell what is its size in bytes. I did the following
which works fine with int variables or any other type provided you adapt it:

Doug and Igor gave you good advice on this, but I want to expand on one
point Doug said, because it points out a potential misunderstanding.

In general, a function has no idea what size "thing" was passed to it. With
your example:

    int varSize( int variable )
    { ... }

In VC++, "variable" will always be a 32-bit integer inside varSize, no
matter what is passed in:

   char x1;
   short x2;
   int x4;
   double d8;
   varSize( x1 );
   varSize( x2 );
   varSize( x4 );
   varSize( d8 );

Those 4 function calls will all work, and varSize will receive a 32-bit
integer.

This extends to C++ classes as well. If I have a base class and a derived
class:

   class base {
      int fill1[8];
   };
   class derived: public base {
      int fill2[8];
   };

In VC++, "base" will be 32 bytes, "derived" will be 64 bytes. But let's
say I do this:

    int varSize( base & b )
    { ... }

    derived d;
    varSize( d );

This is also perfectly legal, but inside varSize, "b" will always be 32
bytes.
--
Tim Roberts, timr@probo.com
Providenza & Boekelheide, Inc.