Conversion

Non, non, j'aurais eu à écrire cette fonction je l'aurais faite comme telle:

#include "assert.h"

inline
void convertir( char *c )
{
   assert( ( 'A' <= *c ) && ( *c <= 'Z' ) );
   (*c) -= 32;
}

Ce qui est équivalent au final.

Le inline demande à ce que lors de la compilation la fonction soit intégrée au code et non codée comme un appel à une fonction. C'est envisageable ici car la fonction est très petite et ne va être appelée que peu de fois. (hors boucles)

le assert est une fonction qui fait planter le programme si la condition est fausse. Il en sort généralement une phrase du style: "Assertion failed: ( 'A' <= *c ) && ( *c <= 'Z' ) in file blabla.c, line xyz"
Par convention la fonction assert est définie différemment selon une macro.

Dans Visual C++ par exemple:

#ifdef  NDEBUG

#define assert(_Expression)     ((void)0)    // La fonction est remplacée 
   //   par une ligne qui ne fait rien et qui sera même retirée par le compilateur.

#else
   // sinon la fonction est définie pour planter en cas d'erreur. (via une autre fonction)
#define assert(_Expression) (void)( (!!(_Expression)) || (_wassert(_CRT_WIDE(#_Expression), _CRT_WIDE(__FILE__), __LINE__), 0) )

#endif  /* NDEBUG */

Il faut que tu vérifies dans ton assert.h quelle est la macro utilisée.

Après, si tu utilises gcc par exemple, tu peux compiler avec gcc -DNomDeLaMacro ... pour définir la macro.
Cela permet de compiler facilement une version de debug et une de release.

(ici Visual n'est pas malin car plutôt que de devoir définir une macro pour désactiver, on en met plutôt une pour activer, généralement nommée _DEBUG, il se rattrappe car il crée systématiquement deux configurations prédéfinies pour compiler mais bon...)

M.

Whoops, je dis des conneries...


*c = ( *c-32 );
est équivalent à

*c = *( c-32 );
Ce qui revient à prendre le caractère situé 32 caractères avant celui désigné par le pointeur.


la syntaxe correcte est
*c = (*c) - 32;


En somme, l'opérateur - est prioritaire sur l'opérateur * (de déréférencment)