Explication pour la coulée de la valeur de retour qui se passe

Question

#include <Fl/Enumerations.H> 
class Color 
{ 
    public: 
     static Color amber() {return fl_rgb_color (255, 204, 0);} 
     static Color lighter_gray() {return fl_rgb_color (40, 40, 40); } 
     static Color light_gray() {return fl_rgb_color (179, 179, 179);} 
     static Color gray() {return fl_rgb_color (100, 100, 100);} 
     static Color light_blue() {return fl_rgb_color (107, 107, 255);} 
     static Color white() {return FL_WHITE;} 
     static Color off_white() { return fl_rgb_color(225, 225, 225); } 
     static Color cream() { return fl_rgb_color(204, 236, 255); } 
     static Color black() {return FL_BLACK;} 
     static Color red() {return FL_RED;} 
     static Color green() {return FL_GREEN;} 
     static Color dark_green() {return fl_rgb_color (0, 169, 45);} 
     static Color blue() {return FL_BLUE;} 
     static Color background() {return FL_BACKGROUND_COLOR;} 

     Color (const Fl_Color& c = Color::black()) : fl_color_ (c) {} 
     operator Fl_Color() const {return fl_color_;} 
     void make_current() const; 

    private: 
     Fl_Color fl_color_; 
}; 

ce qui est un extrait des parties importantes de Fl/Enumerations.h

enum Fl_Color { // standard colors 
    // These are used as default colors in widgets and altered as necessary 
    FL_FOREGROUND_COLOR = 0, 
    FL_BACKGROUND2_COLOR = 7, 
    FL_INACTIVE_COLOR = 8, 
    FL_SELECTION_COLOR = 15, 

    // boxtypes generally limit themselves to these colors so 
    // the whole ramp is not allocated: 
    FL_GRAY0  = 32, // 'A' 
    FL_DARK3  = 39, // 'H' 
    FL_DARK2  = 45, // 'N' 
    FL_DARK1  = 47, // 'P' 
    FL_BACKGROUND_COLOR = 49, // 'R' default background color 
    FL_LIGHT1  = 50, // 'S' 
    FL_LIGHT2  = 52, // 'U' 
    FL_LIGHT3  = 54, // 'W' 

    // FLTK provides a 5x8x5 color cube that is used with colormap visuals 
    FL_BLACK  = 56, 
    FL_RED  = 88, 
    FL_GREEN  = 63, 
    FL_YELLOW  = 95, 
    FL_BLUE  = 216, 
    FL_MAGENTA  = 248, 
    FL_CYAN  = 223, 
    FL_DARK_RED  = 72, 

    FL_DARK_GREEN  = 60, 
    FL_DARK_YELLOW = 76, 
    FL_DARK_BLUE  = 136, 
    FL_DARK_MAGENTA = 152, 
    FL_DARK_CYAN  = 140, 

    FL_WHITE  = 255 
}; 

#define FL_FREE_COLOR  (Fl_Color)16 
#define FL_NUM_FREE_COLOR 16 
#define FL_GRAY_RAMP  (Fl_Color)32 
#define FL_NUM_GRAY  24 
#define FL_GRAY   FL_BACKGROUND_COLOR 
#define FL_COLOR_CUBE  (Fl_Color)56 
#define FL_NUM_RED  5 
#define FL_NUM_GREEN  8 
#define FL_NUM_BLUE  5 

FL_EXPORT Fl_Color fl_inactive(Fl_Color c); 
FL_EXPORT Fl_Color fl_contrast(Fl_Color fg, Fl_Color bg); 
FL_EXPORT Fl_Color fl_color_average(Fl_Color c1, Fl_Color c2, float weight); 
inline Fl_Color fl_lighter(Fl_Color c) { return fl_color_average(c, FL_WHITE, .67f); } 
inline Fl_Color fl_darker(Fl_Color c) { return fl_color_average(c, FL_BLACK, .67f); } 
inline Fl_Color fl_rgb_color(uchar r, uchar g, uchar b) { 

    if (!r && !g && !b) return FL_BLACK; 
    else return (Fl_Color)(((((r << 8) | g) << 8) | b) << 8); 
} 
inline Fl_Color fl_rgb_color(uchar g) { 
    if (!g) return FL_BLACK; 
    else return (Fl_Color)(((((g << 8) | g) << 8) | g) << 8); 
} 
inline Fl_Color fl_gray_ramp(int i) {return (Fl_Color)(i+FL_GRAY_RAMP);} 
inline Fl_Color fl_color_cube(int r, int g, int b) { 
    return (Fl_Color)((b*FL_NUM_RED + r) * FL_NUM_GREEN + g + FL_COLOR_CUBE);} 

Je suis incapable de concentrer mon esprit sur ce qui se passe dans la classe suivante en ce qui concerne les définitions de classes statiques retournant des énumérations FL_COLOR. Je ne peux pas voir comment Fl_Color pourrait avoir une quelconque connaissance de la classe Color et comment le compilateur pourrait avoir une idée de la façon de convertir une Fl_Color en une couleur. Je me rends compte que Color a une conversion implicite en Fl_Color, mais je ne pensais pas que la conversion allait dans les deux sens. Comment cela marche-t-il? Est-ce que le compilateur appelle simplement le constructeur et transmet la valeur de retour comme premier paramètre?

Answer 1

Les méthodes statiques retournant un Color renvoient toutes le résultat d'un appel à fl_rgb_color.

fl_rgb_color retourne une Fl_Color et Color a un seul constructeur de paramètre qui n'est pas marqué explicit et prend une référence à un const Fl_Color c'est donc une conversion de implict valide.

La valeur de retour de fl_rgb_color est temporaire mais parce que Color prend le paramètre Fl_Color par une référence const il est légal de lier le temporaire au paramètre du constructeur. Sa durée de vie dure jusqu'à la fin de la construction de l'objet Color (lui-même également temporaire pour une valeur de retour).

Answer 2

implicitement le constructeur exécute couleur sur le F1_color avant de retourner

Answer 3

Le constructeur de couleur prend utilisera implicitement un paramètre Fl_Color de sorte que le compilateur de convertir Fl_Color à couleur si nécessaire. C'est un comportement normal pour les constructeurs C++ qui prennent un seul paramètre et ne sont pas marqués avec le mot-clé explicite.

Answer 4

Fl_Color est implicitement convertible en Color, car Color a un constructeur non-explicite qui prend Fl_Color comme paramètre.