CareerCup

int a;
int *pa = &a;
int *ps = pa+1;
int sz = (int)ps - (int)pa; // the size of the variable @a

#define size_of( variable ) ((size_t)(&(variable)+1)-(size_t)(&(variable)))

#include <stdio.h>

#define mysizeof(type) (int)(&type+1)-(int)(&type)

struct temp
{
char *a;
int b;
float d[4];

};
int main()
{
int a;
char *p;
char b[5];
int d[10];
float c;
struct temp temp1;
printf("Size of p = %d \n",(int)(&a+1)-(int)(&a));
printf("Size of a = %d \n",sizeof(a));
printf("Size of a = %d \n",mysizeof(a));
printf("Size of p = %d \n",mysizeof(p));
printf("Size of b = %d \n",mysizeof(b));
printf("Size of d = %d \n",mysizeof(d));
printf("Size of c = %d \n",mysizeof(c));
printf("Size of Struct Size temp1 = %d \n",sizeof(temp1));
printf(" MyStruct Size = %d \n",mysizeof(temp1));

}
o/p:-
Size of p = 4
Size of a = 4
Size of a = 4
Size of p = 4
Size of b = 5
Size of d = 40
Size of c = 4
Size of Struct Size temp1 = 24
MyStruct Size = 24

#include<stdio.h>

#define any_size(any) (char*)(&any)-(char*)((&any)-1)

void main()
{
char c; //any type of variable char c;
printf("%d",any_size(c));
getch();
}

It can be found through following ways:
1. pointer airthmatic that is take pointer of same type, increment it and get difference between 2 memory addresses.
2. by storing largest value. Assume its integer and try to store number 2^n starting from 0. Compare stored value with original number.
If it is same, icrement number otherwise stop and n is the bit size of this data type.
3. Through shift operation. Intially set variable to -1. Then do right shift untill you getback number equal to 0.
Count how many times you shifted. This is the size of variable in bits.

int a=(char *) ( &variable+1 ) - (char *)( &variable );

variable can be any data type i.e(Basic, Derive, Userdefine(struct,enum) ).

size of variable = Runtime.getRuntime().totalMemory - Runtime.getRuntime().freeMemory;

yes,,,,5ts g66d

#include<stdio.h>
void main()
{
	int x[2];
	long int xa[2];
	float y[2];
	double z[2];
	char *a,*b;
	a=(char *)&x[0];
	b=(char *)&x[1];
	printf("size of int=%d\n",b-a);
	a=(char *)&xa[0];
	b=(char *)&xa[1];
	printf("size of long double=%d\n",b-a);
	a=(char *)&y[0];
	b=(char *)&y[1];
	printf("size of float=%d\n",b-a);
	a=(char *)&z[0];
	b=(char *)&z[1];
	printf("size of double=%d\n",b-a);

}

Instead of doing all this why can't we take the hexadecimal value of the character and do XOR operation with all the numbers from 0 to 256 and whichever value gives 0 return that value.

Let X be the Data Type of the variable.
#include<stdio.h>
int main()
{
X array[2]={a,b};//a and b can have any value according to the data type
int size=&X[1 ]- &X[0];
printf("%d",size);
return 0;
}

#include<stdio.h>
main()
{
int *p=0;
p++;
printf("%d",p); //size of int, u can find size of other data types in the same way
}

u can find it by luking at itz datatype and if in case u hv forgotten d datatype den u may as well use a bitwise operation like shiftleft bitwise on d variable until it becums itself.
hope dis may b f sum use to u.....:-)