sizeof operator

Détermine la taille de l'objet ou du type.

Utilisé lorsque la taille réelle de l'objet doit être connue.

Syntaxe

Le résultat d'une expression sizeof est une expression constante de type std::size_t .

Notes

Selon l'architecture de l'ordinateur, un byte peut être composé de 8 bits ou plus, le nombre exact étant enregistré dans CHAR_BIT .

Les expressions sizeof suivantes s'évaluent toujours à 1 :

• sizeof ( char )
• sizeof ( signed char )
• sizeof ( unsigned char )

sizeof ne peut pas être utilisé avec des types de fonction, des types incomplets ou des lvalues (jusqu'en C++11) glvalues (depuis C++11) de champ de bits.

Lorsqu'il est appliqué à un type référence, le résultat est la taille du type référencé.

Lorsqu'il est appliqué à un type de classe, le résultat est le nombre d'octets occupés par un objet complet de cette classe, incluant tout remplissage supplémentaire requis pour placer cet objet dans un tableau. Le nombre d'octets occupés par un sous-objet potentiellement chevauchant peut être inférieur à la taille de cet objet.

Le résultat de sizeof est toujours non nul, même s'il est appliqué à un type de classe vide.

Lorsqu'il est appliqué à une expression, sizeof n' évalue pas l'expression (c'est-à-dire que l'expression est un opérande non évalué) (depuis C++11) , et même si l'expression désigne un objet polymorphe, le résultat est la taille du type statique de l'expression. Les conversions lvalue-vers-rvalue, tableau-vers-pointeur ou fonction-vers-pointeur ne sont pas effectuées. La matérialisation temporaire , cependant, est (formellement) réalisée pour les arguments prvalue : le programme est mal formé si l'argument n'est pas destructible. (depuis C++17)

Mots-clés

sizeof

Exemple

#include <cstdlib>
#include <iostream>
struct Empty          { };
struct Base           { int a; };
struct Derived : Base { int b; };
struct Bit            { unsigned bit: 1; };
struct CharChar       { char c; char c2; };
struct CharCharInt    { char c; char c2; int i; };
struct IntCharChar    { int i;  char c;  char c2; };
struct CharIntChar    { char c; int i;   char c2; };
struct CharShortChar  { char c; short s; char c2; };
int main()
{
    Empty e;
    Derived d;
    Base& b = d;
    [[maybe_unused]] Bit bit;
    int a[10];
    auto f = [&]() { return sizeof(int[10]) == sizeof a ? throw 1 : e; };
//  f(); // le type de retour est Empty, mais lance toujours 1
    auto println = [](auto rem, std::size_t size) { std::cout << rem << size << '\n'; };
    println( "1) taille d'une classe vide :              ", sizeof e                     );
    println( "2) taille d'un pointeur :                  ", sizeof &e                    );
    println( "3) taille de la classe Bit :               ", sizeof(Bit)                  );
    println( "4) taille de int[10] tableau de 10 int : ", sizeof(int[10])              );
    println( "5) taille de a        tableau de 10 int : ", sizeof a                     );
    println( "6) longueur du tableau de 10 int :       ", ((sizeof a) / (sizeof *a))   );
    println( "7) longueur du tableau de 10 int (2) :   ", ((sizeof a) / (sizeof a[0])) );
    println( "8) taille de la classe Derived :        ", sizeof d                     );
    println( "9) taille de Derived via Base : ", sizeof b                     );
    println( "A) taille de unsigned :                ", sizeof(unsigned)             );
    println( "B) taille de int :                     ", sizeof(int)                  );
    println( "C) taille de short :                   ", sizeof(short)                );
    println( "D) taille de char :                    ", sizeof(char)                 );
    println( "E) taille de CharChar :                ", sizeof(CharChar)             );
    println( "F) taille de CharCharInt :             ", sizeof(CharCharInt)          );
    println( "G) taille de IntCharChar :             ", sizeof(IntCharChar)          );
    println( "H) taille de CharIntChar :             ", sizeof(CharIntChar)          );
    println( "I) taille de CharShortChar :           ", sizeof(CharShortChar)        );
    println( "J) taille de f() :                      ", sizeof f()                   );
    println( "K) taille de Base::a :                  ", sizeof Base::a               );
//  println( "taille d'une fonction :        ", sizeof(void()) ); // erreur
//  println( "taille d'un type incomplet : ", sizeof(int[])  ); // erreur
//  println( "taille d'un champ de bits :       ", sizeof bit.bit ); // erreur
}

1) sizeof classe vide :              1
2) sizeof pointeur :                 8
3) sizeof classe Bit :               4
4) sizeof tableau int[10] :         40
5) sizeof tableau de 10 int :       40
6) longueur tableau de 10 int :     10
7) longueur tableau de 10 int (2) : 10
8) sizeof classe Dérivée :          8
9) sizeof Dérivée via Base :        4
A) sizeof(unsigned) :               4
B) sizeof(int) :                    4
C) sizeof(short) :                  2
D) sizeof(char) :                   1
E) sizeof(CharChar) :               2
F) sizeof(CharCharInt) :            8
G) sizeof(IntCharChar) :            8
H) sizeof(CharIntChar) :            12
I) sizeof(CharShortChar) :          6
J) sizeof f() :                     1
K) sizeof Base::a :                 4

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi