Que fait static_assert et à quoi l'utiliseriez-vous?

Pourriez-vous donner un exemple où static_assert(...)('C ++ 11') résoudrait le problème en question avec élégance?

Je connais le run-time assert(...). Quand devrais-je préférer static_assert(...)au régulier assert(...)?

En outre, boostil y a quelque chose qui s'appelle BOOST_STATIC_ASSERT, est-ce la même chose que static_assert(...)?

Du haut de ma tête...

#include "SomeLibrary.h"

static_assert(SomeLibrary::Version > 2, 
         "Old versions of SomeLibrary are missing the foo functionality.  Cannot proceed!");

class UsingSomeLibrary {
   // ...
};

En supposant que cela SomeLibrary::Versionsoit déclaré comme un const statique, plutôt que d'être #defined (comme on pourrait s'y attendre dans une bibliothèque C ++).

Contraste d'avoir à compiler en fait SomeLibraryet votre code, tout lien, et lancez l'exécutable seulement alors pour savoir que vous avez passé 30 minutes compilant une version incompatible SomeLibrary.

@Arak, en réponse à votre commentaire: oui, vous pouvez vous static_assertasseoir n'importe où, à première vue:

class Foo
{
    public: 
        static const int bar = 3;
};

static_assert(Foo::bar > 4, "Foo::bar is too small :(");

int main()
{ 
    return Foo::bar;
}

$ g ++ --std = c ++ 0x a.cpp
a.cpp: 7: erreur: l'assertion statique a échoué: "Foo :: bar est trop petit :("

L'assertion statique est utilisée pour faire des assertions au moment de la compilation. Lorsque l'assertion statique échoue, le programme ne se compile tout simplement pas. Ceci est utile dans différentes situations, comme, par exemple, si vous implémentez une fonctionnalité par code qui dépend de manière critique d'un unsigned intobjet ayant exactement 32 bits. Vous pouvez mettre une affirmation statique comme celle-ci

static_assert(sizeof(unsigned int) * CHAR_BIT == 32);

dans votre code. Sur une autre plate-forme, avec un unsigned inttype de taille différente, la compilation échouera, attirant ainsi l'attention du développeur sur la partie problématique du code et lui conseillant de le réimplémenter ou de le réinspecter.

Pour un autre exemple, vous voudrez peut-être passer une valeur intégrale en tant que void *pointeur vers une fonction (un hack, mais parfois utile) et vous voulez vous assurer que la valeur intégrale tiendra dans le pointeur

int i;

static_assert(sizeof(void *) >= sizeof i);
foo((void *) i);

Vous souhaiterez peut-être que l'élément dont le chartype est signé

static_assert(CHAR_MIN < 0);

ou cette division intégrale avec des valeurs négatives arrondit vers zéro

static_assert(-5 / 2 == -2);

Etc.

Dans de nombreux cas, les assertions d'exécution peuvent être utilisées à la place des assertions statiques, mais les assertions d'exécution ne fonctionnent qu'au moment de l'exécution et uniquement lorsque le contrôle passe sur l'assertion. Pour cette raison, une assertion d'exécution défaillante peut rester inactive, non détectée pendant de longues périodes.

Bien sûr, l'expression dans l'assertion statique doit être une constante au moment de la compilation. Il ne peut pas s'agir d'une valeur d'exécution. Pour les valeurs d'exécution, vous n'avez pas d'autre choix que d'utiliser l'ordinaire assert.

Je l'utilise pour m'assurer que mes hypothèses sur le comportement du compilateur, les en-têtes, les bibliothèques et même mon propre code sont correctes. Par exemple ici, je vérifie que la structure a été correctement compressée à la taille attendue.

struct LogicalBlockAddress
{
#pragma pack(push, 1)
    Uint32 logicalBlockNumber;
    Uint16 partitionReferenceNumber;
#pragma pack(pop)
};
BOOST_STATIC_ASSERT(sizeof(LogicalBlockAddress) == 6);

Dans un emballage de classe stdio.h« s fseek()je, pris des raccourcis avec enum Originet vérifier que ces raccourcis sont alignés avec les constantes définies parstdio.h

uint64_t BasicFile::seek(int64_t offset, enum Origin origin)
{
    BOOST_STATIC_ASSERT(SEEK_SET == Origin::SET);

Vous devriez préférer static_assertau assertmoment où le comportement est défini au moment de la compilation, et non au moment de l'exécution, comme les exemples que j'ai donnés ci-dessus. Un exemple où ce n'est pas le cas inclurait la vérification des paramètres et du code de retour.

BOOST_STATIC_ASSERTest une macro pré-C ++ 0x qui génère du code non conforme si la condition n'est pas satisfaite. Les intentions sont les mêmes, bien que static_assertstandardisées et peuvent fournir de meilleurs diagnostics du compilateur.

BOOST_STATIC_ASSERTest un wrapper multi-plateforme pour la static_assertfonctionnalité.

Actuellement, j'utilise static_assert pour appliquer des "Concepts" à une classe.

exemple:

template <typename T, typename U>
struct Type
{
  BOOST_STATIC_ASSERT(boost::is_base_of<T, Interface>::value);
  BOOST_STATIC_ASSERT(std::numeric_limits<U>::is_integer);
  /* ... more code ... */
};

Cela provoquera une erreur de compilation si l'une des conditions ci-dessus n'est pas remplie.

Une utilisation de static_assertpeut être de s'assurer qu'une structure (c'est-à-dire une interface avec le monde extérieur, comme un réseau ou un fichier) est exactement de la taille que vous attendez. Cela attraperait les cas où quelqu'un ajoute ou modifie un membre de la structure sans se rendre compte des conséquences. Le static_assertramasserait et alerterait l'utilisateur.

En l'absence de concepts, on peut utiliser static_assertpour une vérification de type simple et lisible à la compilation, par exemple, dans les modèles:

template <class T>
void MyFunc(T value)
{
static_assert(std::is_base_of<MyBase, T>::value, 
              "T must be derived from MyBase");

// ...
}

Cela ne répond pas directement à la question d'origine, mais constitue une étude intéressante sur la façon d'appliquer ces vérifications de temps de compilation avant C ++ 11.

Le chapitre 2 (section 2.1) de Modern C ++ Design par Andrei Alexanderscu implémente cette idée d'assertions au moment de la compilation comme ceci

template<int> struct CompileTimeError;
template<> struct CompileTimeError<true> {};

#define STATIC_CHECK(expr, msg) \
{ CompileTimeError<((expr) != 0)> ERROR_##msg; (void)ERROR_##msg; } 

Comparez la macro STATIC_CHECK () et static_assert ()

STATIC_CHECK(0, COMPILATION_FAILED);
static_assert(0, "compilation failed");

Le static_assertpeut être utilisé pour interdire l'utilisation du deletemot-clé de cette façon:

#define delete static_assert(0, "The keyword \"delete\" is forbidden.");

Chaque développeur C ++ moderne voudra peut-être le faire s'il souhaite utiliser un garbage collector conservateur en utilisant uniquement les classes es et struct s qui surchargent l' opérateur new pour appeler une fonction qui alloue de la mémoire sur le tas conservateur du garbage collector conservateur qui peut être initialisé et instancié en invoquant une fonction qui fait cela au début de la mainfonction.

Par exemple, chaque développeur C ++ moderne qui souhaite utiliser le garbage collector conservateur Boehm-Demers-Weiser écrira au début de la mainfonction:

GC_init();

Et dans chaque classet structsurcharge de operator newcette façon:

void* operator new(size_t size)
{
     return GC_malloc(size);
}

Et maintenant que le operator deleten'est plus nécessaire, parce que le garbage collector conservateur de Boehm-Demers-Weiser est responsable à la fois de libérer et de désallouer chaque bloc de mémoire lorsqu'il n'est plus nécessaire, le développeur veut interdire le deletemot - clé.

Une façon est de surcharger de delete operatorcette façon:

void operator delete(void* ptr)
{
    assert(0);
}

Mais ce n'est pas recommandé, car le développeur C ++ moderne saura qu'il / elle a invoqué par erreur delete operatorle temps d'exécution, mais il est préférable de le savoir bientôt au moment de la compilation.

Donc, la meilleure solution à ce scénario à mon avis est d'utiliser le static_assertcomme indiqué au début de cette réponse.

Bien sûr, cela peut également être fait avec BOOST_STATIC_ASSERT, mais je pense que static_assertc'est mieux et que cela devrait toujours être préféré.