variable de type double

Bonjour,

j'ai une variable de type double.
cette variable est rattaché à un champ.
Par défaut aujourd'hui ma variable affiche zéro. Maintenant je voudrais mettre mon champ à "vide" (ou NULL)

J'ai effectué cette démarche :

Code:

---

1 2 3

double test; test = NULL;

---

mais après compilation, par défaut il m'affiche zéro au lieu de vide.
Comment faire ?

NULL, c'est pour les pointeurs. Il faut donc que tu déclares ta variable comme pointeur (si possible intelligent).

Null est destiné au pointeur. Il est plus ou moins équivalent à "&rien" (1).
Or double n'est pas un pointeur. Un double à toujours une valeur, car c'est un type primitif.

Par ailleurs, si tu es en C++11, préfères null_ptr à NULL.
Le compilateur t'aurai hurlé dessus pour cause de conversion illégale.

Pour représenter une variable potentiellement indéfinie, on préfère soit boost::optionnal, soit une implémentation à la main du concept, telle que:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

template <typename T> class undefinable{ private: bool defined; T lastContent;   public: undefinable(T& value):defined(true), lastContent(value){} undefinable():defined(false){}   bool isSet() const {return defined;} //j'utilise throw false pour simplifier, il vaut mieux creer une exception T operator() () const {if(defined) return lastContent; else throw false;}   undefinable& operator= (const T& value) { defined=true; lastContent=value; return *this; } undefinable& unset() { defined = false; return *this;} }

---

(1) Pour les linuxiens, je préfère dire &</dev/null>...

Citation:

---

Envoyé par leternel

Par ailleurs, si tu es en C++11, préfères null_ptr à NULL.
Le compilateur t'aurai hurlé dessus pour cause de conversion illégale.

Pour représenter une variable potentiellement indéfinie, on préfère soit boost::optionnal, soit une implémentation à la main du concept, telle que:

---

On peut également utiliser, en C++, NaN.

merci de vos réponses

Salut,

En fait, c'est un problème qui est régulièrement rencontré lorsqu'il s'agit de travailler avec des base de données :

Certains champs peuvent être "nuls", ce qui correspond à une "valeur indéfinie".

Le problème, c'est que cette notion n'existe pas en tant que telle en C++.

Par chance (enfin, si on peut s'exprimer ainsi), les requêtes SQL que l'on va générer ne sont, en définitive, que des chaines de caractères qu'il nous appartient de générer de manière automatique.

La solution généralement employée pour représenter indéfinie d'indéfinie est de choisir une valeur (pourtant bel et bien définie :D ) clairement identifiable qui ne risque en aucun cas d'être utilisée pour autre chose (comprends : en tant que valeur réelle) et de faire un test au moment de la génération de la requête SQL.

Il existe, en gros trois cas "principaux" :

1. Le cas des pointeurs
2. Le cas des réels
3. Le cas des entiers

Pour les pointeurs, nous disposons déjà d'une valeur permettant de représenter un pointeur invalide: NULL (nullptr en C++11) et cette valeur "ne pointant sur rien" est donc un candidat idéal pour représenter "quelque chose qui n'existe pas"

Comme les pointeurs sont implicitement convertibles en un boléen de valeur false s'ils valent NULL (ou nullptr) et de valeur true s'il valent "autre chose", il est possible de générer la requête sous une forme proche de

Code:

---

1 2 3 4

std::stringstream ss; ss <<"insert into table set(champs1, champs2) " <<value(<<(ptr ? ptr->membre : "NULL");

---

Pour les réels, il existe en effet une valeur représentant "Not A Number" (ceci n'est pas un nombre réel 8O) : NAN.

Cette valeur (qui n'en représente pas une) est disponibles pour les type float, double et long double (si présents) dans numeric_limits, disponible dans l'espace de noms std par inclusion du fichier d'en-tête <limits> sous la forme de std::numeric_limits<double>::quiet_NaN(); ou de std::numeric_limits<double>::signaling_NaN(); en fonction du système.

Tu pourrais donc, effectivement, envisager de travailler sous une forme proche de

Code:

---

1 2 3 4 5

static double const unsetDouble = std::numeric_limits<double>::quiet_NaN(); // respectivement std::numeric_limits<double>::signaling_NaN(); std::stringstream ss; ss <<"insert into table set(champs1, champs2) " <<value(<<(mondouble == unsetDouble ? mondouble : "NULL");

---

Enfin, pour les entiers, c'est souvent la valeur renvoyée par std::numeric_limits<type>::max() qui sera utilisée (std::string::npos, par exemple).

Le principe est alors le même que pour les réels, mais en utilisant std::numeric_limits<type>::max() en lieu et place de std::numeric_limits<type>::quiet_NaN(); ou de std::numeric_limits<type>::signaling_NaN();