размер типа данных без использования sizeof

На мой взгляд, это укладывается в категорию «как добавить два целых числа без использования ++, + = или +?». Это пустая трата времени. Вы можете попытаться избежать монстров неопределенного поведения, сделав что-то подобное.

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

Обратите внимание, что я не объявляю переменную типа или указателя на X.

Послушайте, sizeof - языковое средство для этого. Единственный, так что это единственный переносимый способ добиться этого.

В некоторых особых случаях вы можете сгенерировать непереносимый код, который использует другую эвристику для понимания размера конкретных объектов [*] (возможно, заставляя их отслеживать свой собственный размер), но вам придется выполнять всю бухгалтерию самостоятельно .

[*] Объекты в очень общем смысле, а не в смысле ООП.

Что ж, я любитель ... но я попробовал эту проблему и получил правильный ответ, не используя sizeof. Надеюсь, это поможет ... Я пытаюсь найти размер целого числа.

int *a,*s, v=10;

a=&v;

s=a;

a++;

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

printf("%d",intsize);

Правильный ответ на этот вопрос собеседования: «Зачем мне это нужно, если sizeof () делает это за меня и является единственным переносимым методом для этого?»

Возможность заполнения препятствует всем надеждам без знания правил, используемых для его введения. И это зависит от реализации.

Вы можете разгадать это, прочитав , в котором размещены структуры вашей памяти ABI, nofollow, nofollow в вашем процессоре. Это потенциально разное для каждого процессора. Но если вы не пишете компилятор, удивительно, что вы не хотите просто использовать sizeof, что является единственно правильным способом решения этой проблемы.

если X - тип данных:

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

если X - переменная:

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

Попробуй это:

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

Загляните в исходники компилятора. Ты получишь :

• размер стандартных типов данных.
• правила заполнения структур

и отсюда ожидаемый размер чего угодно.

Если бы вы могли хотя бы выделить место для переменной и ввести в нее какое-то контрольное значение, вы могли бы изменить его бит за битом и посмотреть, изменится ли значение, но это все равно не сообщит вам никакой информации о заполнении.

Попробуй это:

 #include<stdio.h>

int main(){

  int *ptr = 0;

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

  return 0;

Доступно с версии C89, которая в пользовательском коде:

1. Не объявляет переменную типа X.
2. Не объявляет указатель на тип X.
3. Без использования оператора sizeof.

Достаточно просто сделать, используя стандартный код, как подсказал @steve jessop

offsetof(type, member-designator)

которое расширяется до целочисленного константного выражения типа size_t, значение которого представляет собой смещение в байтах, до элемента структуры ..., от начала его структуры ... 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;
}

Примечание. В этом коде используется "%zu", для которого требуется C99 и далее.

Это код: уловка состоит в том, чтобы создать объект-указатель, сохранить его адрес, увеличить указатель и затем вычесть новый адрес из предыдущего. Ключевым моментом является то, что когда указатель увеличивается, он фактически перемещается на размер, равный объекту, на который он указывает, поэтому здесь размер класса (из которого объект, на который он указывает).

#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);
}

С Уважением

Многие из этих ответов предполагают, что вы знаете, как будет выглядеть ваша структура. Я считаю, что этот вопрос на собеседовании призван побудить вас мыслить нестандартно. Я искал ответ, но не нашел здесь подходящих решений. Я сделаю лучшее предположение, сказав

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

Создав foo [2], я теперь буду иметь в памяти 2 последовательных объекта foo. Так...

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

return (&b-&a);

Предполагая, что мои арифметические операции с указателем были выполнены правильно, это должен быть билет - и его переносимый! К сожалению, такие вещи, как отступы, настройки компилятора и т. Д., Тоже сыграли свою роль.

Мысли?

поместите это в свой код

затем проверьте вывод компоновщика (файл карты)

unsigned int  uint_nabil;
unsigned long  ulong_nabil;

у вас получится что-то вроде этого;

uint_nabil 700089a8 00000004
ulong_nabil 700089ac    00000004

4 это размер !!

Один простой способ сделать это - использовать массивы. Теперь мы знаем, что в массивах элементы одного типа данных хранятся в непрерывном блоке памяти. Итак, используя этот факт, я пришел к следующему:

#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;
}

Надеюсь это поможет.

Попробуй это,

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

Для следующего определяемого пользователем типа данных

struct x
{
    char c;
    int i;
};

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

При этом учитывается, что байт C ++ не всегда состоит из 8 двоичных разрядов и что только беззнаковые типы имеют четко определенное поведение переполнения.

#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";
}

Конечно, вы могли бы просто #include <limit> или <climits>.

    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);
    }

С помощью этого скрипта кода размер любых данных может быть вычислен без оператора sizeof. Просто измените значение с плавающей запятой в строке 1 на тип, размер которого вы хотите вычислить.