#include <iostream>

class c{
};


int main() {
    std::cout << sizeof(c) << std::endl;
    return 0;
}

out: 1

откуда 1 байт взялся?
платформа MS Visual 2003

посмотри
http://www.cantrip.org/emptyopt.html

Здравствуйте, Аноним, Вы писали:


А>

А>#include <iostream>

А>class c{
А>};


А>int main() {
А>    std::cout << sizeof(c) << std::endl;
А>    return 0;
А>}

А>

А>out: 1

А>откуда 1 байт взялся?
А>платформа MS Visual 2003

из определения что разные объекты класса должные иметь разные адреса

Здравствуйте, Аноним, Вы писали:

А>откуда 1 байт взялся?
А>платформа MS Visual 2003

Если мне не изменяет память, то экзепляр такого класса в качестве члена в другом классе может не занимать места. Т.е.

class my
{
public:
  int x;
  empty y;
};

// sizeof(my) == sizeof(int)

это фейковый размер. нужен только для того, чтобы были возможны подобные конструкции:

#include <iostream>

class c{
    public:    
        c() { std::cout << "c";}
};    


int main() {
    std::cout << sizeof(c) << std::endl;
    c ac[10];
    
    return 0;
}

Аноним 217 пишет:

> откуда 1 байт взялся?

Размер любого объекта программы на С++ по стандарту не может быть меньше 1 байта
(точнее одного идентифицируемого на данной платформе элемента памяти). Это
связано с тем, что никакие два разных объекта не могут иметь одинаковые адреса.
Если размер объекта был бы 0, то в массиве таких объектов все элементы имели
бы одинаковый адрес, а это недопустимо.

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

Здравствуйте, MasterZiv, Вы писали:

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

Как так? Откуда компилятор знает, адресую я мембер или нет?

Пример:

emptyClass.h:

class empty{};

struct containsEmpty
{
  empty e; //пустой член
  char c;  //нормальный член
  void someFunc();
};

emptyClass.cpp:

void containsEmpty::someFunc()
{
  void * ptr1 = &e;//поадресовали
  void * ptr2 = &c;//поадресовали
  printf("%d", sizeof(containsEmpty)); //должно быть не менее sizeof(char) + 1 (для "поадресованного" e)
}

somewhere.cpp:

#include "emptyClass.h"
//не поадресовали
void someClass::someOtherFunc()
{
  printf("%d", sizeof(containsEmpty)); //должно быть не менее sizeof(char) + 0(???) (для "непоадресованного" e)
}

То есть в ед.трансл. emptyClass.cpp мы обращались к e, там всё как-бы ясно, адреса у e и c должны отличаться.
А в ед.трансл somewhere.cpp мы к е не обращались, при её компиляции компилятор явно не в курсе, что е — адресуется. Каков будет результат?