static_assert

Test een software-assertie tijdens het compileren. Als de opgegeven constante expressie is false, geeft de compiler het opgegeven bericht weer, als er een is opgegeven en de compilatie mislukt met fout C2338; anders heeft de declaratie geen effect.

Syntaxis

static_assert( constant-expression, string-literal );

static_assert( constant-expression ); // C++17 (Visual Studio 2017 and later)

Parameterwaarden

constante expressie
Een integrale constante expressie die kan worden geconverteerd naar een Booleaanse waarde. Als de geëvalueerde expressie nul (onwaar) is, wordt de parameter tekenreeks-letterlijk weergegeven en mislukt de compilatie met een fout. Als de expressie niet-nul (true) is, heeft de static_assert declaratie geen effect.

letterlijke tekenreeks
Een bericht dat wordt weergegeven als de parameter voor constante expressie nul is. Het bericht is een tekenreeks in de basistekenset van de compiler; Dat wil gezegd, geen multibyte of brede tekens.

Opmerkingen

De parameter voor constante expressie van een static_assert declaratie vertegenwoordigt een software-assertie. Een softwareverklaring geeft een voorwaarde aan die u verwacht op een bepaald punt in uw programma waar te zijn. Als de voorwaarde waar is, heeft de static_assert declaratie geen effect. Als de voorwaarde onwaar is, mislukt de assertie, geeft de compiler het bericht weer in de letterlijke parameter tekenreeks en mislukt de compilatie met een fout. In Visual Studio 2017 en hoger is de parameter voor letterlijke tekenreeksen optioneel.

De static_assert declaratie test een softwareverklaring tijdens het compileren. De functies Macro en _assert en _wassert daarentegen testen een softwareverklaring tijdens runtime en kosten in de uitvoeringstijd en kosten voor runtime. De static_assert declaratie is vooral handig voor het opsporen van fouten in sjablonen, omdat sjabloonargumenten kunnen worden opgenomen in de parameter voor constante expressie .

De compiler onderzoekt de static_assert declaratie voor syntaxisfouten wanneer de declaratie wordt aangetroffen. De compiler evalueert de parameter voor constante expressie onmiddellijk als deze niet afhankelijk is van een sjabloonparameter. Anders evalueert de compiler de parameter voor constante expressie wanneer de sjabloon wordt geïnstantieerd. Als gevolg hiervan kan de compiler een diagnostisch bericht uitgeven wanneer de declaratie wordt aangetroffen en opnieuw wanneer de sjabloon wordt geïnstantieerd.

U kunt het static_assert trefwoord gebruiken voor naamruimte, klasse of blokbereik. (Het static_assert trefwoord is technisch gezien een declaratie, ook al introduceert het geen nieuwe naam in uw programma, omdat het kan worden gebruikt bij het bereik van de naamruimte.)

Beschrijving van static_assert met naamruimtebereik

In het volgende voorbeeld heeft de declaratie het bereik van de static_assert naamruimte. Omdat de compiler de grootte van het type void *kent, wordt de expressie onmiddellijk geëvalueerd.

Voorbeeld: static_assert met naamruimtebereik

static_assert(sizeof(void *) == 4, "64-bit code generation is not supported.");

Beschrijving van static_assert met klassebereik

In het volgende voorbeeld heeft de static_assert declaratie een klassebereik. Hiermee static_assert wordt gecontroleerd of een sjabloonparameter een normaal oud gegevenstype (POD) is. De compiler onderzoekt de static_assert declaratie wanneer deze wordt gedeclareerd, maar evalueert de parameter voor constante expressie pas nadat de basic_string klassesjabloon is geïnstantieerd.main()

Voorbeeld: static_assert met klassebereik

#include <type_traits>
#include <iosfwd>
namespace std {
template <class CharT, class Traits = std::char_traits<CharT> >
class basic_string {
    static_assert(std::is_pod<CharT>::value,
                  "Template argument CharT must be a POD type in class template basic_string");
    // ...
    };
}

struct NonPOD {
    NonPOD(const NonPOD &) {}
    virtual ~NonPOD() {}
};

int main()
{
    std::basic_string<char> bs;
}

Beschrijving van static_assert met blokbereik

In het volgende voorbeeld heeft de static_assert declaratie een blokbereik. Hiermee static_assert wordt gecontroleerd of de grootte van de VMPage-structuur gelijk is aan de pagina's van het virtuele geheugen van het systeem.

Voorbeeld: static_assert bij blokbereik

#include <sys/param.h> // defines PAGESIZE
class VMMClient {
public:
    struct VMPage { // ...
           };
    int check_pagesize() {
    static_assert(sizeof(VMPage) == PAGESIZE,
        "Struct VMPage must be the same size as a system virtual memory page.");
    // ...
    }
// ...
};

Zie ook

Assertion and User-Supplied Messages (C++)
#error Richtlijn (C/C++)
macro, _assert, _wassert
Sjablonen
ASCII-tekenset
Declaraties en definities