size of a datatype without using sizeof

Question

I have a data type, say X, and I want to know its size without declaring a variable or pointer of that type and of course without using sizeof operator.

Is this possible? I thought of using standard header files which contain size and range of data types but that doesn't work with user defined data type.

Answer 1

#include <bits/stdc++.h> 

using namespace std; 

int main() 
{ 

    // take any datatype hear 
    char *a = 0; // output: 1

    int  *b = 0;  // output: 4

    long *c = 0; // output: 8

    a++;

    b++;

    c++;

    printf("%d",a);

    printf("%d",b);

    printf("%d",c);

    return 0; 
}

Answer 2

One simple way of doing this would be using arrays. Now, we know for the fact that in arrays elements of the same datatype are stored in a contiguous block of memory. So, by exploiting this fact I came up with following:

#include <iostream>
using namespace std;

int main()
{
    int arr[2];
    int* ptr = &arr[0];
    int* ptr1 = &arr[1];
    cout <<(size_t)ptr1-(size_t)ptr;
}

Hope this helps.

Answer 3

put this to your code

then check the linker output ( map file)

unsigned int  uint_nabil;
unsigned long  ulong_nabil;

you will get something like this ;

uint_nabil 700089a8 00000004
ulong_nabil 700089ac    00000004

4 is the size !!

Answer 4

# include<stdio.h>

struct node
{
  int a;
  char c;
};

void main()
{
   struct node*ptr;
   ptr=(struct node*)0;
   printf("%d",++ptr);
}

Answer 5

Available since C89 solution that in user code:

1. Does not declare a variable of type X.
2. Does not declare a pointer to type X.
3. Without using sizeof operator.

Easy enough to do using standard code as hinted by @steve jessop

offsetof(type, member-designator)

which expands to an integer constant expression that has type size_t, the value of which is the offset in bytes, to the structure member ..., from the beginning of its structure ... C11 §7.19 3

#include <stddef.h>
#include <stdio.h>

typedef struct {
  X member;
  unsigned char uc;
} sud03r_type;

int main() {
  printf("Size X: %zu\n", offsetof(sud03r_type, uc));
  return 0;
}

Note: This code uses "%zu" which requires C99 onward.

Answer 6

#include <stdio.h>

struct {
  int a;
  char c;
};

void main() {
  struct node*temp;
  printf("%d",(char*)(temp+1)-(char*)temp);
}

Answer 7

    main()    
    {
    clrscr();
    int n;
    float x,*a,*b;//line 1
    a=&x;
    b=(a+1);
    printf("size of x is %d",
    n=(char*)(b)-(char*)a);
    }

By this code script the size of any data can be calculated without sizeof operator.Just change the float in line 1 with the type whose size you want to calculate

Answer 8

Try This:

 #include<stdio.h>

int main(){

  int *ptr = 0;

  ptr++;
  printf("Size of int:  %d",ptr);

  return 0;

Answer 9

A lot of these answers are assuming you know what your structure will look like. I believe this interview question is intended to ask you to think outside the box. I was looking for the answer but didn't find any solutions I liked here. I will make a better assumption saying

struct foo {
  int a;
  banana b;
  char c;
  ...
};

By creating foo[2], I will now have 2 consecutive foo objects in memory. So...

foo[2] buffer = new foo[2];
foo a = buffer[0];
foo b = buffer[1];

return (&b-&a);

Assuming did my pointer arithmetic correctly, this should be the ticket - and its portable! Unfortunately things like padding, compiler settings, etc.. would all play a part too

Thoughts?

Answer 10

This is the code: The trick is to make a pointer object, save its address, increment the pointer and then subtract the new address from the previous one. Key point is when a pointer is incremented, it actually moves by the size equal to the object it is pointing, so here the size of the class (of which the object it is pointing to).

#include<iostream>
using namespace std;
 class abc
    {
           int a[5];
           float c;           
    };
main()
{
    abc* obj1;
    long int s1;
    s1=(int)obj1; 
    obj1++;
    long int s2=(int)obj1;
    printf("%d",s2-s1);
}

Regards

Answer 11

Try this:

int a;
printf("%u\n", (int)(&a+1)-(int)(&a));

Answer 12

This takes into account that a C++ byte is not always 8 binary bits, and that only unsigned types have well defined overflow behaviour.

#include <iostream>
int main () {
    unsigned int i = 1;
    unsigned int int_bits = 0;
    while (i!=0) {
        i <<= 1;
        ++int_bits;
    }

    unsigned char uc = 1;
    unsigned int char_bits = 0;
    while (uc!=0) {
        uc <<= 1;
        ++char_bits;
    }

    std::cout << "Type int has " << int_bits << "bits.\n";
    std::cout << "This would be  " << int_bits/8 << " IT bytes and "
              << int_bits/char_bits << " C++ bytes on your platform.\n";
    std::cout << "Anyways, not all bits might be usable by you. Hah.\n";
}

Surely, you could also just #include <limit> or <climits>.

Answer 13

if X is datatype:

#define SIZEOF(X) (unsigned int)( (X *)0+1 )

if X is a variable:

#define SIZEOF(X) (unsigned int)( (char *)(&X+1)-(char *)(&X) )

Answer 14

Try this,

#define sizeof_type( type )  ((size_t)((type*)1000 + 1 )-(size_t)((type*)1000))

For the following user-defined datatype,

struct x
{
    char c;
    int i;
};

sizeof_type(x)          = 8
(size_t)((x*)1000 + 1 ) = 1008
(size_t)((x*)1000)      = 1000

Answer 15

Look, sizeof is the language facility for this. The only one, so it is the only portable way to achieve this.

For some special cases you could generate un-portable code that used some other heuristic to understand the size of particular objects[*] (probably by making them keep track of their own size), but you'd have to do all the bookkeeping yourself.

[*] Objects in a very general sense rather than the OOP sense.

Answer 16

The correct answer to this interview question is "Why would I want to do that, when sizeof() does that for me, and is the only portable method of doing so?"

Answer 17

Well, I am an amateur..but I tried out this problem and I got the right answer without using sizeof. Hope this helps.. I am trying to find the size of an integer.

int *a,*s, v=10;

a=&v;

s=a;

a++;

int intsize=(int)a-(int)s;

printf("%d",intsize);

Answer 18

To my mind, this fits into the category of "how do I add two ints without using ++, += or + ?". It's a waste of time. You can try and avoid the monsters of undefined behaviour by doing something like this.

size_t size = (size_t)(1 + ((X*)0));

Note that I don't declare a variable of type or pointer to X.

Answer 19

Look into the compiler sources. You will get :

• the size of standard data types.
• the rules for padding of structs

and from this, the expected size of anything.

If you could at least allocate space for the variable, and fill some sentinel value into it, you could change it bit by bit, and see if the value changes, but this still would not tell you any information about padding.

Answer 20

You could puzzle it out by reading the ABI for your particular processor, which explains how structures are laid out in memory. It's potentially different for each processor. But unless you're writing a compiler it's surprising you don't want to just use sizeof, which is the One Right Way to solve this problem.

Answer 21

The possibility of padding prevent all hopes without the knowledge of the rules used for introducing it. And those are implementation dependent.