vérification si variable int vide ou pas

**kripteks** · 31/03/2014, 19h43

Salut à tous.
Comment je pourrais vérifier si une variable int est vide ou pas ? si on a pas encore donné une valeur.

**Trademark** · 31/03/2014, 19h44

Tu ne peux pas, mais tu peux fixer une valeur "sentinelle" à l'initialisation comme -1 ou 0. Ou encore utiliser un type "option".

**Iradrille** · 31/03/2014, 20h07

Une variable, même non initialisée possède une valeur. Tu peux le vérifier simplement

Code :

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

1
2
3
4
5
6
#include <iostream>
int main() {
   int i;
   std::cout << i << std::endl;
   return 0;
}

Si tu as vraiment besoin d'une variable qui ne possède pas de valeur quand non initialisée, tu peux utiliser boost::optional.

**kripteks** · 31/03/2014, 20h45

Merci pour les réponses.

L'application sera utiliser en cgi pour faire un site web.

Parfois depuis le visiteur, parfois depuis la base de donnée, j'ai des valeurs vide qui viennent.

Et je dois faire des vérifications pour faire les bonnes actions.

Sachant que pour un site web, on a pas mal de variable int à vérifier, je sais pas quel bonne méthode choisir.

(En langage C c'est pareil ?)

**Trademark** · 31/03/2014, 22h26

Tout dépend de l'interface avec laquelle tu récupères tes valeurs, en consultant la documentation tu peux savoir comment faire.

**white_tentacle** · 01/04/2014, 10h19

En général, pour représenter une valeur vide, on utilise une paire <booléen, valeur>. Le booléen est à vrai si la valeur est initialisée (par exemple, on peut aussi utiliser la convention inverse, le tout est de s’y tenir). boost optional est une solution, d’autant que comme c’est juste un en-tête, ce n’est pas un problème à rajouter dans un projet.

Les solutions à base de valeur magiques ne sont pas géniales, et posent pas mal de problèmes, sauf si tu as la garantie que ta valeur « magique » est en dehors de l’intervalle des valeurs possibles (mais dans tous les cas, ce sera peu lisible).

**r0d** · 02/04/2014, 14h33

Envoyé par kripteks

(En langage C c'est pareil ?)

Oui, c'est pareil en C, et dans beaucoup d'autres langages (PHP, java pour les types primitifs, etc.).
L'idée c'est que les types primitifs ne correspondent à rien d'autre qu'un morceau de mémoire. L'identifiant d'une variable détermine l'adresse de la variable (où est-elle stockée), son type détermine sa taille (le nombre de bits utilisés pour représenter sa valeur).
Donc, puisqu'une variable (dans le cas où son type est primitif) correspond à un morceau de mémoire, c'est à dire une série de bits, et que ces bits ont tous obligatoirement une valeur (0 ou 1), une variable a obligatoirement une valeur. D'où la distinction entre la déclaration et l'initialisation d'une variable. Lorsqu'on déclare une variable, on lui donne une adresse et un taille. Lorsqu'on l'initialise, on lui donne une valeur. En C++, une bonne pratique consiste à faire les deux en même temps, systématiquement: lorsqu'on déclare une variable, on l'initialise (~~ce qu'on ne peut pas faire en C~~):

Code :

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

int ma_variable = 0;

Dans ton cas, pour formaliser ce qui a déjà été dit, il y a 3 solutions possibles:
1. Utiliser une valeur par défaut pour chacune de tes variables. Cette valeur sera utilisée pour l'initialisation (en même temps que la déclaration donc). Inconvénient: il faut que cette valeur soit choisie de façon à ce que la variable ne puisse jamais être assignée à cette valeur autre part qu'à son initialisation.
2. Encapsuler tes variables pour les lier avec un champ dédié. Le simple est une paire (std::pair<bool, LeTypeDeMaVariable>) dont le premier élément (le booléen) détermine si la variable a été initialisée. Inconvénient: petite perte de performance.
3. Utiliser boost::optional, que je ne connais pas donc je n'en connais pas les inconvénients.