Comment puis-je écrire une variable d'un type défini par l'utilisateur dans un flux

Question

Je ne veux pas dire une variable dans une classe mais une valeur par défaut pour la classe dans son ensemble.

struct Scalar { 
    unsigned int value; 

    void toThePowerOf(int power); 
    // etc. 
} 

Je voudrais pouvoir faire quelque chose comme

Scaler foo; 
foo.value = 2; 
foo.toThePowerOf(2); 

std::cout << foo << std::endl; // Outputs 4! 

Est-ce possible en C++?

Answer 1

je voulais dire une valeur par défaut pour la classe, donc si vous avez appelé cet objet par son nom juste foo il retournerait foo.value par défaut.

Il est en effet possible de définir une conversion implicite de Scalar à int:

struct Scalar 
{ 
    unsigned int value; 

    operator int() const 
    { 
     return value; 
    } 
}; 

int main() 
{ 
    Scalar foo = {2}; 
    std::cout << foo << std::endl; 
} 

Mais les conversions implicites sont généralement réprouvée dans le C++ communauté, car il peut rendre le code assez difficile à lire. (Je suppose que c'est pourquoi personne n'a encore mentionné les opérateurs de conversion.)

Answer 2

Non, vous ne pouvez pas mais vous pouvez surcharger l'opérateur < < pour votre classe et ostream pour obtenir l'effet désiré

std::ostream& operator << (std::ostream& out, const Scaler& foo) 
{ 
    return out << foo.value; 
} 

Votre code va maintenant travailler et produire les désirs résultent

Answer 3

Non, les classes ne pas avoir une valeur dans la façon dont vous pensez.

Qu'est-ce que vous voulez dire probablement faire est de surcharger l'opérateur < <:

ostream& operator<<(ostream& output, const Scalar& val) 
{ 
    output << val.value; 
    return output; 
} 

Answer 4

Oui. c'est possible. Juste initialiser toutes les valeurs dans le constructeur de la classe. Utilisez la classe au lieu de struct.

Answer 5

Utilisez une valeur par défaut dans le ctor. Rendez le ctor explicite si vous ne voulez pas de conversions implicites.

struct Scalar { 
    unsigned int value; 

    Scalar(int value=0) : value (value) {} 

    void toThePowerOf(int power) { 
    // naive implementation just for show 
    int new_value = 1; 
    assert(power >= 0); // or other error checking 
    for (; power > 0; --power) { 
     new_value *= value; 
    } 
    value = new_value; 
    } 

    friend std::ostream& operator<<(std::ostream &out, Scalar const &x) { 
    out << x.value; 
    return out; 
    } 
};