Ich habe festgestellt, dass sowohl MSVC- als auch GCC-Compiler mindestens ein Byte pro Klasseninstanz zuweisen, auch wenn die Klasse ein Prädikat ohne Mitgliedsvariablen (oder nur mit statischen Mitgliedsvariablen) ist. Der folgende Code veranschaulicht den Punkt.

#include <iostream>

class A
{
public:
   bool operator()(int x) const
   {
      return x>0;
   }
};

class B
{
public:
   static int v;
   static bool check(int x)
   {
      return x>0;
   }
};

int B::v = 0;

void test()
{
   A a;
   B b;
   std::cout << "sizeof(A)=" << sizeof(A) << "\n"
             << "sizeof(a)=" << sizeof(a) << "\n"
             << "sizeof(B)=" << sizeof(B) << "\n"
             << "sizeof(b)=" << sizeof(b) << "\n";
}

int main()
{
   test();
   return 0;
}

Ausgabe

sizeof(A)=1
sizeof(a)=1
sizeof(B)=1
sizeof(b)=1

Meine Frage ist, warum braucht der Compiler das? Der einzige Grund, den ich finden kann, besteht darin, sicherzustellen, dass sich alle Member-Var-Zeiger unterscheiden, damit wir zwischen zwei Member des Typs A oder B unterscheiden können, indem wir Zeiger mit ihnen vergleichen. Die Kosten hierfür sind jedoch bei kleinen Behältern recht hoch. Unter Berücksichtigung einer möglichen Datenausrichtung können wir ohne Variablen (?!) Bis zu 16 Bytes pro Klasse erhalten. Angenommen, wir haben einen benutzerdefinierten Container, der in der Regel einige int-Werte enthält. Betrachten Sie dann ein Array solcher Container (mit ungefähr 1000000 Mitgliedern). Der Overhead wird 16 * 1000000 sein! Ein typischer Fall, in dem dies passieren kann, ist eine Containerklasse mit einem Vergleichsprädikat, das in einer Mitgliedsvariablen gespeichert ist. In Anbetracht der Tatsache, dass eine Klasseninstanz immer etwas Platz einnehmen sollte, ist mit welchem Overhead beim Aufruf von A () (value) zu rechnen?