Flexible convertir entre string, int, double pour le C++ Variante de la Classe

À mettre en place quelque chose comme cela, vous devez être en mesure de changer le stockée type, parce que si l'utilisateur modifie la variable par référence, il veut le changement d'affecter la valeur stockée, alors j'aimerais écrire quelque chose comme ceci:

class Variant
{
private:
enum StoreType
{
Integer,
Float,
String,
}
store_type;
union
{
int * as_integer;
double * as_double;
std::string * as_string;
}
store_pointer;
//convert to type
void integer_to_double();
void integer_to_string();
void double_to_integer();
void double_to_string();
void string_to_integer();
void string_to_double();
public:
...
int & ToInt()
{
switch (store_type)
{
case Integer: break;
case Double: double_to_integer(); break;
case String: string_to_integer(); break;
}
return * as_integer;
}
...
}

OriginalL'auteur Evan Dark

Tout d'abord, avez-vous absolument besoin de retour par référence? Retour par valeur serait probablement plus facile, car vous pourriez le faire à tout moment sans avoir à modifier l'état interne de l'objet Variant.

Si vous avez absolument besoin de retour par référence, alors vous devez avoir un valide emplacement de mémoire pour renvoyer une référence. (Ainsi, par exemple, renvoie une référence à une pile d'objet n'est pas bon, parce que la pile de l'objet aurait disparu lors de la ToXXX() la méthode retourne, et la référence pourrait être une référence à une mémoire non valide)

Le moyen facile de le faire serait d'ajouter un (mutable?) variable de membre de chaque type dans votre Variante de l'objet, et de définir cette variable membre de la valeur et de renvoyer une référence en tant que de besoin. Bien sûr que l'inconvénient de cette méthode est qu'elle permet à votre Variante objets aussi grand que la somme de tous les objets, mais qui pourrait être bien si vous ne vous souciez pas beaucoup au sujet de l'utilisation de la mémoire.

Si vous ne vous souciez de minimiser l'utilisation de la mémoire de votre Variante objets aussi, alors vous aurez probablement besoin d'utiliser un syndicat (ou quelque chose d'équivalent à un). C syndicats de travail pour les POD types, mais si vous avez besoin d'inclure des non-POD types (par exemple std::string objets) qu'ils ne seront pas suffisantes. Si vous avez besoin, vous pouvez aller avec un octet de la mémoire tampon (qui est assez grand pour le plus grand type d'ajustement) et l'aide au placement de nouvelles et destructeur explicite des appels lorsque cela est nécessaire, mais il est un peu délicate à mettre en œuvre.

Autant que les conversions de types de données (par exemple, "7" -> (int)7 -> (double)7.0, vous devez simplement mettre en œuvre une logique (peut-être par imbriqués les instructions switch?) pour faire la bonne chose pour chaque paire possible de "source" et "destination". Je ne pense pas qu'il y est de la magie chemin autour de cela, bref de l'aide de stimuler la fonctionnalité, où il a été fait pour vous.

OriginalL'auteur Jeremy Friesner

Voici un moyen rapide et sale de la mise en œuvre à l'aide de boost::any que la valeur titulaire à la place de classes personnalisées. Comme vous pouvez le voir, les modèles peuvent aider un peu pour garder la quantité de code un peu plus courte.

ToXXX fonctions de changer le type sous-jacent de la valeur stockée (sauf si aucune conversion n'est nécessaire), puis renvoyer une référence. Les Conversions sont effectuées à l'aide boost::lexical_cast, qui ne peut être entièrement adapté à vos besoins (il lève des exceptions si les conversions ne sont pas une réussite, selon lexical_cast de conditions très strictes).

#include <boost/any.hpp>
#include <boost/lexical_cast.hpp>
#include <string>
#include <typeinfo>
class Variant
{
boost::any value;
public:
Variant(int n): value(n) {}
Variant(double d): value(d) {}
Variant(const std::string& s): value(s) {}
Variant(const char* s): value(std::string(s)) {} //without this, string literals create ambiguities
int& ToInt() { return convert<int>();}
double& ToDouble() { return convert<double>(); }
std::string& ToString() { return convert<std::string>(); }
private:
template <class T>
T& convert()
{
if (typeid(T) != value.type()) { //otherwise no conversion required
if (typeid(int) == value.type()) {
value = boost::lexical_cast<T>(boost::any_cast<int>(value));
}
else if (typeid(double) == value.type()) {
value = boost::lexical_cast<T>(boost::any_cast<double>(value));
}
else if (typeid(std::string) == value.type()) {
value = boost::lexical_cast<T>(boost::any_cast<std::string>(value));
}
}
return *boost::any_cast<T>(&value);
}
};
#include <iostream>
using namespace std;
int main()
{
Variant a = 7;
cout << "The answer is" + a.ToString() << endl; //should print "The answer is 7"
a = "7.4";
double &b = a.ToDouble();
b += 1;
cout << a.ToString() << endl; //should print 8.4
}

(En action: http://codepad.org/C3l5AXg3)

La mise en œuvre pourrait être encore plus simple avec boost::variant<int, double, std::string>, comme vous pourriez être en mesure de le retirer avec un seul visiteur basé sur un modèle operator() au lieu d'avoir à écrire un code distinct chemin d'accès pour chacun des différents types.

OriginalL'auteur UncleBens

Compte tenu de ce que vous avez besoin, je suggère de télécharger http://qt.nokia.com et à la recherche dans une mise en œuvre de QVariant Classe. Si cela vous semble trop compliqué, je dirais quelque chose comme ceci:

class Variant
{
private:
enum data_type {
...
};
data_type variant_type;
union Data {
char *string;
int integer;
double dbl;
} data;
public:
Variant(const int data);
Variant(const double data);
Variant(const char *data);
// I think that implementation of the constructors should be pretty straight forward.
int ToInt() const; 
double ToDouble() const; 
std::string ToString() const;
};

La mise en œuvre de la conversion devrait être simple à partir d'ici.

Si vous souhaitez plus simple et la performance n'est pas une préoccupation majeure des données stockées dans la variante pourrait être converti en chaîne de caractères, puis convertie en arrière lorsque la méthode est appelée.

class Variant
{
private:
char data_string[16384];
public:
Variant(const int data);
Variant(const double data);
Variant(const char *data);
// I think that implementation of the constructors should be pretty straight forward.
int ToInt() const; 
double ToDouble() const; 
std::string ToString() const;
};

Si vous avez besoin de détails de mise en œuvre pour les fonctions de conversion je peux les fournir, mais je pense qu'ils devraient être assez simple.

OriginalL'auteur Karlson