Discussion :

[oodini]

Hello,

Je lis le tout premier article d' Andrzej, qui traite des assertions.

À un moment, il définit une macro :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
#define ASSERT(_COND) \
  static_cast<void>( sizeof((_COND) ? true : false) )

Mais je ne suis pas sûr d'en comprendre le but.
Il évoque le cas d'assertions trop coûteuses à évaluer, mais pour lesquelles on voudrait toutefois vérifier la syntaxe.
J'ai du mal à réellement voir une utilité à cela, mais soit.

Mais quel est l'intérêt du sizeof ?
Andrzej précise : sizeof has exactly the properties we need.
Mais quelles sont les propriétés en question ?

[Pyramidev]

La propriété dont il parle est la suivante :

When applied to an expression, sizeof does not evaluate the expression

Source : http://en.cppreference.com/w/cpp/language/sizeof

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
 
#define ASSERT1(_COND) \
  static_cast<void>( sizeof((_COND) ? true : false) )
 
#define ASSERT2(_COND) \
  static_cast<void>( (_COND) ? true : false )
 
int main()
{
    ASSERT1(std::cout << "foo"); // n'écrit rien
    ASSERT2(std::cout << "bar"); // écrit "bar"
    return 0;
}

[oodini]

Donc, le but est de vérifier que _COND est une expression valide, qui serait capable de se convertir en booléen, sans pour autant évaluer l'opérateur ternaire, au cas où _COND aurait d'éventuels effets de bords (du genre ++i>j) ?
Le static_cast étant là pour éviter d'éventuels warnings du genre "variable non utilisée" ?

[Pyramidev]

Andrzej a écrit :

The main purpose of assertion is simply to be there, in the code, and for the programmer to be able to see what is asserted. What it does at run-time is of secondary importance, and assertions may as well do nothing at run-time (debugging or release mode) and they would still be useful.
[...]
Also, there are assertions that cannot be checked even in debugging mode. For example, binary search requires that the range be sorted. Verifying if the range is sorted has linear complexity whereas searching itself is logarithmic. If our function is called often and our condition is checked time and again even for medium-sized data, the assertion may be an overkill.

Donc ce serait pour faire du code dans ce genre-là :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#define UNCHECKED_ASSERT(_COND) \
  static_cast<void>( sizeof((_COND) ? true : false) ) // _COND n'est pas évalué, mais doit être convertible en bool.
 
BinaryTree::add(const Element& element)
{
    UNCHECKED_ASSERT(isSorted());
 
    // code
 
    UNCHECKED_ASSERT(isSorted());
}

En fait, c'est pareil que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
BinaryTree::add(const Element& element)
{
    // isSorted() est vrai.
 
    // code
 
    // isSorted() est vrai.
}

sauf que le compilateur vérifie que isSorted() compile et est convertible en booléen.

Le static_cast étant là pour éviter d'éventuels warnings du genre "variable non utilisée" ?

C'est pour éviter un avertissement du style "valeur non utilisée".

[oodini]

OK, merci à toi !