Statique affirmer en C

Quelle est la meilleure façon de parvenir à la compilation statique affirme en C (pas C++), avec un accent particulier sur GCC?

Voici un retardataire réponse de la mienne qui fonctionne en C++11 ou une version ultérieure et avec toutes les modernes gcc le compilateur C versions: stackoverflow.com/a/54993033/4561887

InformationsquelleAutor Matt Joiner | 2010-08-02

73

C11 standard ajoute le _Static_assert mot-clé.

C'est mis en œuvre depuis gcc-4.6:
```
_Static_assert (0, "assert1"); /* { dg-error "static assertion failed: \"assert1\"" } */
```
La première machine à sous doit être une expression constante. Le second logement est une constante chaîne de caractères littérale qui peut être long (_Static_assert(0, L"assertion of doom!")).

Je tiens à noter que c'est également mise en œuvre dans les versions récentes de clang.
- [...semble être mis en œuvre par gcc, par clang...], Vous pouvez être plus affirmée que ça 😉 _Static_assert fait partie de la norme C11 et un compilateur qui prend en charge C11, aurez.
- Cela peut-il être utilisé à la portée (en dehors de toute fonction)? Parce que je suis error: expected declaration specifiers or '...' before 'sizeof' pour la ligne static_assert( sizeof(int) == sizeof(long int), "Error!); (je suis en utilisant C pas du C++ par la voie)
- Je suis surpris que cela ne fonctionne pas.. Attendez, vous êtes absent une citation à la fin de votre chaîne d'erreur. Les placer et de revenir. Cela fonctionne pour moi sur gcc-4.9: _Static_assert( sizeof(int) == sizeof(long int), "Error!"); Sur ma macine je reçois le message d'erreur.
- J'ai le gcc 4.8.2 sur Ubuntu. Le guillemet manquant était un commentaire faute de frappe (je l'ai eu dans le code). C'est la première ligne d'un fichier, après une couple d'en-tête comprend. Le compilateur me donne deux exactement la même erreur: error: expected declaration specifiers or '...' before 'sizeof' ET error: expected declaration specifiers or '...' before string constant (il se réfère à la "Error!"string) (aussi: je suis de la compilation avec -std=c11. Lors de la mise de la déclaration à l'intérieur d'une fonction tous fonctionne bien (échoue et réussit comme prévu))
- J'ai également eu l'option-std=gnu11 sur la ligne de commande. Je suis vraiment surpris qu'il y aurait une différence entre 4,8 et 4.8. J'ai une source avec une seule ligne. J'ai aussi utilisé le C standard _Static_assert pas le C++ish static_assert. Vous devez " #include <assert.h> pour obtenir le static_assert macro.
- Merci c'est elle! J'ai été en utilisant un c++ IDE orienté vers cette auto en surbrillance static_assert comme valable même si j'ai oublié le <assert.h>. Noob piège :))
- Voici une macro qui utilise gcc est _Static_assert() en C et C++11 est static_assert afin qu'il fonctionne avec gcc, gcc -std=c90, gcc -std=c99, gcc -std=c11, et g++ -std=c++11, etc: stackoverflow.com/a/54993033/4561887
InformationsquelleAutor emsr
80

Cela fonctionne dans la fonction et les non-portée de la fonction (mais pas à l'intérieur des structures,des syndicats).
```
#define STATIC_ASSERT(COND,MSG) typedef char static_assertion_##MSG[(COND)?1:-1]

STATIC_ASSERT(1,this_should_be_true); 

int main()
{
 STATIC_ASSERT(1,this_should_be_true); 
}
```
1. Si le moment de la compilation affirmation n'a pas pu être appariés, puis une presque intelligible message est généré par GCC sas.c:4: error: size of array ‘static_assertion_this_should_be_true’ is negative
2. La macro qui pourrait ou devrait être modifié pour générer un nom unique pour la définition de type (c'est à dire concaténer __LINE__ à la fin de la static_assert_... nom)
3. Au lieu d'un ternaire, ce pourrait être aussi bien utilisé #define STATIC_ASSERT(COND,MSG) typedef char static_assertion_##MSG[2*(!!(COND))-1] qui se passe à travailler encore sur le rusty olde cc65 (pour le processeur 6502) compilateur.
Mise à JOUR:
Par souci d'exhaustivité, voici la version avec __LINE__
```
#define STATIC_ASSERT(COND,MSG) typedef char static_assertion_##MSG[(!!(COND))*2-1]
//token pasting madness:
#define COMPILE_TIME_ASSERT3(X,L) STATIC_ASSERT(X,static_assertion_at_line_##L)
#define COMPILE_TIME_ASSERT2(X,L) COMPILE_TIME_ASSERT3(X,L)
#define COMPILE_TIME_ASSERT(X)    COMPILE_TIME_ASSERT2(X,__LINE__)

COMPILE_TIME_ASSERT(sizeof(long)==8); 
int main()
{
    COMPILE_TIME_ASSERT(sizeof(int)==4); 
}
```
UPDATE2: GCC code spécifique

GCC 4.3 (je suppose) a introduit le "erreur" et "avertissement" de la fonction d'attributs. Si un appel à une fonction avec cet attribut ne peut être éliminée grâce à l'élimination du code mort (ou d'autres mesures), puis une erreur ou un avertissement est généré. Ceci peut être utilisé pour faire de la compilation affirme avec l'utilisateur défini par l'échec des descriptions. Il reste à déterminer comment ils peuvent être utilisés dans l'espace de noms de la portée sans avoir recours à un mannequin de la fonction:
```
#define CTC(X) ({ extern int __attribute__((error("assertion failure: '" #X "' not true"))) compile_time_check(); ((X)?0:compile_time_check()),0; })

//never to be called.    
static void my_constraints()
{
CTC(sizeof(long)==8); 
CTC(sizeof(int)==4); 
}

int main()
{
}
```
Et c'est à quoi il ressemble:
```
$ gcc-mp-4.5 -m32 sas.c 
sas.c: In function 'myc':
sas.c:7:1: error: call to 'compile_time_check' declared with attribute error: assertion failure: `sizeof(int)==4` not true
```
- Dans Visual Studio, il dit juste "Négatif, l'indice", de ne pas mentionner le nom de la variable...
- Nordique Mainframe - option 3 dans votre réponse ne fonctionne pas sur clang.
- Concernant le dernier (GCC 4.3+spécifique) solution: C'est très puissant, car il peut vérifier tout ce que l'optimiseur peut comprendre, mais il échoue si l'optimisation n'est pas activé. Le strict minimum niveau d'optimisation (-Og) peut souvent être assez pour que cela fonctionne, cependant, et ne devrait pas interférer avec le débogage. On peut envisager de faire de la statique affirmer un no-op ou de l'exécution d'affirmer si __OPTIMIZE__ (et __GNUC__) n'est pas défini.
- Dans l'extrait de Code avec la version en LIGNE (mise à JOUR: Par souci d'exhaustivité, voici la version en LIGNE) , lors de la compilation, il des erreurs à la ligne (STATIC_ASSERT(X,static_assertion_at_line_##L)), qui peut être corrigé par l'ajout d'un niveau supplémentaire, comme ci-dessous: #define COMPILE_TIME_ASSERT4(X,L) static_assert(X, L); #define COMPILE_TIME_ASSERT3(X,L) COMPILE_TIME_ASSERT3(X,"l'Assertion"à:##L"");
- J'utilise quelque chose de similaire à la __LINE__ version de gcc 4.1.1 ... avec parfois de l'agacement lorsque deux en-têtes d'arriver à en avoir une sur le même numéro de ligne!
- Le typedef version fonctionne avec tous les compilateurs. Toutefois, si le compilateur prend en charge __attribute__((unused)), il est commode d'ajouter, de peur d'être embêté par -Wunused-local-typedef.
InformationsquelleAutor Nordic Mainframe
11

cl

Je sais que la question mentionne explicitement la gcc, mais juste pour être complet, voici un tweak pour les compilateurs Microsoft.

À l'aide de l'négativement tableau de taille typedef n'a pas réussi à persuader cl à cracher un décent erreur. Il dit seulement error C2118: negative subscript. Un zéro-largeur de champ de bits tarifs mieux à cet égard. Puisqu'il s'agit d'typedeffing un struct, nous avons vraiment besoin d'utiliser des noms de types uniques. __LINE__ ne pas couper la moutarde — il est possible d'avoir un COMPILE_TIME_ASSERT() sur la même ligne dans un en-tête et d'un fichier source, et votre compilation de casser. __COUNTER__ vient à la rescousse (et il a été dans gcc depuis 4.3).
```
#define CTASTR2(pre,post) pre ## post
#define CTASTR(pre,post) CTASTR2(pre,post)
#define STATIC_ASSERT(cond,msg) \
    typedef struct { int CTASTR(static_assertion_failed_,msg) : !!(cond); } \
        CTASTR(static_assertion_failed_,__COUNTER__)
```
Maintenant
```
STATIC_ASSERT(sizeof(long)==7, use_another_compiler_luke)
```
sous cl donne:

erreur C2149: 'static_assertion_failed_use_another_compiler_luke' : nom champ de bits ne peut pas avoir une largeur égale à zéro

Gcc donne également un message intelligible:

erreur: zéro de la largeur de bits ‘static_assertion_failed_use_another_compiler_luke’

InformationsquelleAutor bobbogo
4

De Wikipédia:
```
#define COMPILE_TIME_ASSERT(pred) switch(0){case 0:case pred:;}

COMPILE_TIME_ASSERT( BOOLEAN CONDITION );
```
- Il ne fonctionne pas en dehors des fonctions.
- Il serait mieux si vous avez lié à la véritable source: jaggersoft.com/pubs/CVu11_3.html
- Il ne fonctionne pas dans gcc 4.6 - il est dit que "l'affaire de l'étiquette n'est pas réduit à une constante entière". Il a un point.
- vous avez tous les deux probablement déplacé waaay par maintenant, mais j'ai fini par écrire mon propre (voir la section ma réponse). J'ai utilisé ton lien @MattJoiner pour m'aider
- Et si vous pouvez être dérangé, laissez-moi savoir si cela fonctionne pour vous, @Liosan. J'ai seulement commencé à fouiller dans le C++ donc je viens en retard à la fête
- Comme pour Visual C++, il a static_assert intégré depuis la version 2010, et il fonctionne en c++ et c modes. Cependant, il n'a pas le c99 _Static_assert intégré.
InformationsquelleAutor Tyler
3

Je PAS recommandons l'utilisation de la solution à l'aide d'un typedef:
```
#define STATIC_ASSERT(COND,MSG) typedef char static_assertion_##MSG[(COND)?1:-1]
```
La déclaration de tableau avec typedef mot clé n'est PAS garanti d'être évalués au moment de la compilation. Par exemple, le code suivant dans le bloc de portée de compiler:
```
int invalid_value = 0;
STATIC_ASSERT(invalid_value, this_should_fail_at_compile_time_but_will_not);
```
Je recommanderais ceci à la place (sur C99):
```
#define STATIC_ASSERT(COND,MSG) static int static_assertion_##MSG[(COND)?1:-1]
```
En raison de la static mot-clé, le tableau sera défini au moment de la compilation. Notez que cette assertion ne fonctionne qu'avec COND qui sont évalués au moment de la compilation. Il ne fonctionnera pas (par exemple, la compilation échouera) avec des conditions qui sont fondés sur des valeurs en mémoire, comme les valeurs affectées aux variables.
- Alors que ce serait le travail, il serait également développer votre mémoire.
InformationsquelleAutor FredFredFredFred

Si à l'aide de la STATIC_ASSERT() macro avec __LINE__, il est possible d'éviter la ligne de nombre d'affrontements entre une entrée dans une .c fichier et une autre entrée dans un fichier d'en-tête, y compris __INCLUDE_LEVEL__.

Par exemple :

/* Trickery to create a unique variable name */
#define BOOST_JOIN( X, Y )      BOOST_DO_JOIN( X, Y )
#define BOOST_DO_JOIN( X, Y )   BOOST_DO_JOIN2( X, Y )
#define BOOST_DO_JOIN2( X, Y )  X##Y
#define STATIC_ASSERT(x)        typedef char \
        BOOST_JOIN( BOOST_JOIN(level_,__INCLUDE_LEVEL__), \
                    BOOST_JOIN(_assert_on_line_,__LINE__) ) [(x) ? 1 : -1]

InformationsquelleAutor BrentNZ

1

La méthode la plus classique est l'utilisation d'un tableau:
```
char int_is_4_bytes_assertion[sizeof(int) == 4 ? 1 : -1];
```
Cela fonctionne, car si l'affirmation est vraie que le tableau a de taille 1 et il est valide, mais si elle est fausse la taille de -1 donne une erreur de compilation.

La plupart des compilateurs affichera le nom de la variable et le point à droite de la partie du code où vous pouvez laisser les commentaires éventuels sur l'assertion.
- Emballage en générique #define STATIC_ASSERT() type de macro et de fournir plus de génériques, des exemples et exemples de sortie du compilateur à partir de votre générique des exemples d'utilisation de STATIC_ASSERT() serait de vous donner un beaucoup plus upvotes et de rendre cette technique plus de sens je pense.
- Je ne suis pas d'accord. Le compilateur voit la pensée de macros et de donner une plus message de confusion.
InformationsquelleAutor Paolo.Bolzoni

Parce que:

_Static_assert() est maintenant défini dans gcc pour toutes les versions de C, et
static_assert() est défini en C++11 et plus tard

La macro suivante simple pour `STATIC_ASSERT()` fonctionne donc en:

C++:
1. C++11 (g++ -std=c++11) ou plus tard
C:
1. gcc -std=c90
2. gcc -std=c99
3. gcc -std=c11
4. gcc (pas de mst spécifié)

Définir STATIC_ASSERT comme suit:

/* For C++: */
#ifdef __cplusplus
    #ifndef _Static_assert
        #define _Static_assert static_assert /* `static_assert` is part of C++11 or later */
    #endif
#endif
/* Now for gcc (C) (and C++, given the define above): */
#define STATIC_ASSERT(test_for_true) _Static_assert((test_for_true), "(" #test_for_true ") failed")

Maintenant l'utiliser:

STATIC_ASSERT(1 > 2); //Output will look like: error: static assertion failed: "(1 > 2) failed"

Exemples:

Testé sous Ubuntu à l'aide de gcc 4.8.4:

Exemple 1: bonne gcc de sortie (ie: le STATIC_ASSERT() codes fonctionne, mais que la condition est fausse, en provoquant un moment de la compilation assert):

$ gcc-Wall-o static_assert static_assert.c && ./static_assert

static_assert.c: In function ‘main’

static_assert.c:78:38: erreur: statique échec de l'assertion: "(1 > 2) l'échec de la"

#define STATIC_ASSERT(test_for_true) _Static_assert((test_for_true), "(" #test_for_true ") a échoué")

^

static_assert.c:88:5: remarque: dans l'expansion de la macro ‘STATIC_ASSERT’

STATIC_ASSERT(1 > 2);

^

Exemple 2: bonne g++ -std=c++11 de sortie (ie: le STATIC_ASSERT() codes fonctionne, mais que la condition est fausse, en provoquant un moment de la compilation assert):

$ g++ -Wall-std=c++11 -o static_assert static_assert.c && ./static_assert

static_assert.c: In function ‘int main()’

static_assert.c:74:32: erreur: statique échec de l'assertion: (1 > 2) n'a pas

#define _Static_assert static_assert /* static_assert est une partie de C++11 ou une version ultérieure */

^

static_assert.c:78:38: remarque: dans l'expansion de la macro ‘_Static_assert’

#define STATIC_ASSERT(test_for_true) _Static_assert((test_for_true), "(" #test_for_true ") a échoué")

^

static_assert.c:88:5: remarque: dans l'expansion de la macro ‘STATIC_ASSERT’

STATIC_ASSERT(1 > 2);

^

Exemple 3: échoué sortie C++ (c'est à dire: l'assertion code ne fonctionne pas correctement à tous, puisque c'est à l'aide d'une version de C++ avant C++11):

$ g++ -Wall-o static_assert static_assert.c && ./static_assert

static_assert.c:88:5: avertissement: identificateur ‘static_assert’ est un mot clé dans C++11 [-Wc++0x-compat]

STATIC_ASSERT(1 > 2);

^

static_assert.c: In function ‘int main()’

static_assert.c:78:99: erreur: ‘static_assert " n'a pas été déclarée dans le champ d'application

#define STATIC_ASSERT(test_for_true) _Static_assert((test_for_true), "(" #test_for_true ") a échoué")

^

static_assert.c:88:5: remarque: dans l'expansion de la macro ‘STATIC_ASSERT’

STATIC_ASSERT(1 > 2);

^

Test complet ici:

/*
static_assert.c
- test static asserts in C and C++ using gcc compiler

Gabriel Staples
4 Mar. 2019 

To be posted in:
1. https://stackoverflow.com/questions/987684/does-gcc-have-a-built-in-compile-time-assert/987756#987756
2. https://stackoverflow.com/questions/3385515/static-assert-in-c/7287341#7287341

To compile & run:
  C:
    gcc -Wall -o static_assert static_assert.c && ./static_assert
    gcc -Wall -std=c90 -o static_assert static_assert.c && ./static_assert
    gcc -Wall -std=c99 -o static_assert static_assert.c && ./static_assert
    gcc -Wall -std=c11 -o static_assert static_assert.c && ./static_assert
  C++:
    g++ -Wall -o static_assert static_assert.c && ./static_assert
    g++ -Wall -std=c++98 -o static_assert static_assert.c && ./static_assert
    g++ -Wall -std=c++03 -o static_assert static_assert.c && ./static_assert
    g++ -Wall -std=c++11 -o static_assert static_assert.c && ./static_assert

-------------
TEST RESULTS:
-------------

1. `_Static_assert(false, "1. that was false");` works in:
  C:
    gcc -Wall -o static_assert static_assert.c && ./static_assert             YES
    gcc -Wall -std=c90 -o static_assert static_assert.c && ./static_assert    YES
    gcc -Wall -std=c99 -o static_assert static_assert.c && ./static_assert    YES
    gcc -Wall -std=c11 -o static_assert static_assert.c && ./static_assert    YES
  C++:
    g++ -Wall -o static_assert static_assert.c && ./static_assert             NO
    g++ -Wall -std=c++98 -o static_assert static_assert.c && ./static_assert  NO
    g++ -Wall -std=c++03 -o static_assert static_assert.c && ./static_assert  NO
    g++ -Wall -std=c++11 -o static_assert static_assert.c && ./static_assert  NO

2. `static_assert(false, "2. that was false");` works in:
  C:
    gcc -Wall -o static_assert static_assert.c && ./static_assert             NO
    gcc -Wall -std=c90 -o static_assert static_assert.c && ./static_assert    NO
    gcc -Wall -std=c99 -o static_assert static_assert.c && ./static_assert    NO
    gcc -Wall -std=c11 -o static_assert static_assert.c && ./static_assert    NO
  C++:
    g++ -Wall -o static_assert static_assert.c && ./static_assert             NO
    g++ -Wall -std=c++98 -o static_assert static_assert.c && ./static_assert  NO
    g++ -Wall -std=c++03 -o static_assert static_assert.c && ./static_assert  NO
    g++ -Wall -std=c++11 -o static_assert static_assert.c && ./static_assert  YES

3. `STATIC_ASSERT(1 > 2);` works in:
  C:
    gcc -Wall -o static_assert static_assert.c && ./static_assert             YES
    gcc -Wall -std=c90 -o static_assert static_assert.c && ./static_assert    YES
    gcc -Wall -std=c99 -o static_assert static_assert.c && ./static_assert    YES
    gcc -Wall -std=c11 -o static_assert static_assert.c && ./static_assert    YES
  C++:
    g++ -Wall -o static_assert static_assert.c && ./static_assert             NO
    g++ -Wall -std=c++98 -o static_assert static_assert.c && ./static_assert  NO
    g++ -Wall -std=c++03 -o static_assert static_assert.c && ./static_assert  NO
    g++ -Wall -std=c++11 -o static_assert static_assert.c && ./static_assert  YES

*/

#include <stdio.h>
#include <stdbool.h>

/* For C++: */
#ifdef __cplusplus
    #ifndef _Static_assert
        #define _Static_assert static_assert /* `static_assert` is part of C++11 or later */
    #endif
#endif
/* Now for gcc (C) (and C++, given the define above): */
#define STATIC_ASSERT(test_for_true) _Static_assert((test_for_true), "(" #test_for_true ") failed")


int main(void)
{
    printf("Hello World\n");

    /*_Static_assert(false, "1. that was false");*/
    /*static_assert(false, "2. that was false");*/

    STATIC_ASSERT(1 > 2);

    return 0;
}

InformationsquelleAutor Gabriel Staples

0

Pour ceux qui veulent quelque chose de vraiment basique et portable, mais n'ont pas accès à C++11 caractéristiques, j'ai écrit un peu la chose.

Utilisation STATIC_ASSERT normalement (vous pouvez l'écrire deux fois dans la même fonction si vous voulez) et l'utilisation GLOBAL_STATIC_ASSERT à l'extérieur de fonctions avec une phrase unique en tant que premier paramètre.
```
#if defined(static_assert)
#   define STATIC_ASSERT static_assert
#   define GLOBAL_STATIC_ASSERT(a, b, c) static_assert(b, c)
#else
#   define STATIC_ASSERT(pred, explanation); {char assert[1/(pred)];(void)assert;}
#   define GLOBAL_STATIC_ASSERT(unique, pred, explanation); namespace ASSERTATION {char unique[1/(pred)];}
#endif

GLOBAL_STATIC_ASSERT(first, 1, "Hi");
GLOBAL_STATIC_ASSERT(second, 1, "Hi");

int main(int c, char** v) {
    (void)c; (void)v;
    STATIC_ASSERT(1 > 0, "yo");
    STATIC_ASSERT(1 > 0, "yo");
//   STATIC_ASSERT(1 > 2, "yo"); //would compile until you uncomment this one
    return 0;
}
```
Explication:

_{D'abord, il vérifie si vous avez la vraie affirmer, que vous voulez absolument utiliser si elle est disponible.

Si vous n'avez pas il affirme par l'obtention de votre predicate, et en la divisant par lui-même. Cela ne signifie deux choses.

Si c'est le zéro, id est, l'assertion a échoué, il va provoquer une erreur de division par zéro (l'arithmétique est forcé, parce qu'elle essaye de déclarer un tableau).

Si il n'est pas nul, il normalise la taille de la matrice à 1. Donc, si l'affirmation passé, vous ne voulez pas échouer de toute façon parce que vos prédicat est évalué à -1 (invalide), ou être 232442 (énorme gaspillage de l'espace, IDK si il serait optimisé out).

Pour STATIC_ASSERT il est enveloppé dans des accolades, ce qui en fait un bloc, qui étendues de la variable assert, ce qui signifie que vous pouvez l'écrire à plusieurs reprises.

Il jette aussi à void, qui est un moyen de se débarrasser de unused variable avertissements.

Pour GLOBAL_STATIC_ASSERT, au lieu d'être dans un bloc de code, il génère un espace de noms. Les espaces de noms sont autorisés en dehors des fonctions. Un unique identifiant est nécessaire d'arrêter toutes les définitions contradictoires si vous utilisez plus d'une fois.}

A fonctionné pour moi sur GCC et VS'12 C++
- Il n'y a pas d'espaces de noms dans C.
- ah, oups, mal lu la question. On dirait que je suis venu ici à la recherche d'une réponse à C++ de toute façon (en regardant la dernière ligne de ma réponse), donc je vais le laisser ici, dans le cas où les autres à faire de même
InformationsquelleAutor Hashbrown

Cela fonctionne, avec "supprimer les" option. Je peut utiliser une fonction globale de vérifier les paramètres globaux.

//
#ifndef __sassert_h__
#define __sassert_h__

#define _cat(x, y) x##y

#define _sassert(exp, ln) \
extern void _cat(ASSERT_WARNING_, ln)(void); \
if(!(exp)) \
{ \
    _cat(ASSERT_WARNING_, ln)(); \
}

#define sassert(exp) _sassert(exp, __LINE__)

#endif //__sassert_h__

//-----------------------------------------
static bool tab_req_set_relay(char *p_packet)
{
    sassert(TXB_TX_PKT_SIZE < 3000000);
    sassert(TXB_TX_PKT_SIZE >= 3000000);
    ...
}

//-----------------------------------------
Building target: ntank_app.elf
Invoking: Cross ARM C Linker
arm-none-eabi-gcc ...
../Sources/host_if/tab_if.c:637: undefined reference to `ASSERT_WARNING_637'
collect2: error: ld returned 1 exit status
make: *** [ntank_app.elf] Error 1
//

Si ça marche, c'est seulement dans la source d'un exécutable.

InformationsquelleAutor user4978854

Cela a fonctionné pour certains vieux gcc. Désolé que j'ai oublié quelle version c'était:

#define _cat(x, y) x##y

#define _sassert(exp, ln)\
extern char _cat(SASSERT_, ln)[1]; \
extern char _cat(SASSERT_, ln)[exp ? 1 : 2]

#define sassert(exp) _sassert((exp), __LINE__)

//
sassert(1 == 2);

//
#148 declaration is incompatible with "char SASSERT_134[1]" (declared at line 134)  main.c  /test/source/controller line 134    C/C++ Problem

InformationsquelleAutor jay

De Perl, spécifiquement perl.h de la ligne 3455 (<assert.h> est inclus à l'avance):

/* STATIC_ASSERT_DECL/STATIC_ASSERT_STMT are like assert(), but for compile
   time invariants. That is, their argument must be a constant expression that
   can be verified by the compiler. This expression can contain anything that's
   known to the compiler, e.g. #define constants, enums, or sizeof (...). If
   the expression evaluates to 0, compilation fails.
   Because they generate no runtime code (i.e.  their use is "free"), they're
   always active, even under non-DEBUGGING builds.
   STATIC_ASSERT_DECL expands to a declaration and is suitable for use at
   file scope (outside of any function).
   STATIC_ASSERT_STMT expands to a statement and is suitable for use inside a
   function.
*/
#if (defined(static_assert) || (defined(__cplusplus) && __cplusplus >= 201103L)) && (!defined(__IBMC__) || __IBMC__ >= 1210)
/* static_assert is a macro defined in <assert.h> in C11 or a compiler
   builtin in C++11.  But IBM XL C V11 does not support _Static_assert, no
   matter what <assert.h> says.
*/
#  define STATIC_ASSERT_DECL(COND) static_assert(COND, #COND)
#else
/* We use a bit-field instead of an array because gcc accepts
   'typedef char x[n]' where n is not a compile-time constant.
   We want to enforce constantness.
*/
#  define STATIC_ASSERT_2(COND, SUFFIX) \
    typedef struct { \
        unsigned int _static_assertion_failed_##SUFFIX : (COND) ? 1 : -1; \
    } _static_assertion_failed_##SUFFIX PERL_UNUSED_DECL
#  define STATIC_ASSERT_1(COND, SUFFIX) STATIC_ASSERT_2(COND, SUFFIX)
#  define STATIC_ASSERT_DECL(COND)    STATIC_ASSERT_1(COND, __LINE__)
#endif
/* We need this wrapper even in C11 because 'case X: static_assert(...);' is an
   error (static_assert is a declaration, and only statements can have labels).
*/
#define STATIC_ASSERT_STMT(COND)      STMT_START { STATIC_ASSERT_DECL(COND); } STMT_END

Si static_assert est disponible (à partir de <assert.h>), il est utilisé. Sinon, si la condition est fausse, un peu de champ avec une taille négative est déclarée, ce qui provoque la compilation échoue.

STMT_START /STMT_END sont des macros expansion de do /while (0), respectivement.

InformationsquelleAutor melpomene

Vous devez vous connecter pour publier un commentaire.

cl

Parce que:

La macro suivante simple pour STATIC_ASSERT() fonctionne donc en:

Exemples:

Test complet ici:

La macro suivante simple pour `STATIC_ASSERT()` fonctionne donc en: