Comment est-ce que je peux rendre impossible l'appel de mes fonctions membres de classe dans main?

Question

Je suis en train d'écrire quelques cours pour une tâche de devoirs et je veux qu'il soit impossible que mes fonctions de membre de classe soient appelées en main. Si c'est le cas, je veux que le programme se termine. Comment saurais-je quand mes fonctions de membre sont appelées? Comme pour la classe, chaque objet représente une couleur au format < 100,200,215>. Merci pour l'aide!

class Color{ 

public: 
    Color(unsigned red = 0, unsigned green = 0, unsigned blue = 0); // ctor 
    unsigned getRed() const; // accessor 
    unsigned getGreen() const; // accessor 
    unsigned getBlue() const; // accessor 
    Color & setRed(unsigned red); // mutator 
    Color & setGreen(unsigned green); // mutator 
    Color & setBlue(unsigned blue); // mutator 
    const Color & output() const; 
private: 
    unsigned myRed; 
    unsigned myGreen; 
    unsigned myBlue; 
    static unsigned okColor(unsigned color); 

}; //Class Color 

int main(int argc, const char * argv[]) 
{ 

} 


Color::Color(unsigned red, unsigned green, unsigned blue): 
myRed(okColor(red)),myGreen(okColor(green)),myBlue(okColor(blue)) 
{ 
    //initialization list here... 
} 

//accessors 
unsigned Color::getRed() const {return myRed;} 
unsigned Color::getGreen() const {return myGreen;} 
unsigned Color::getBlue() const {return myBlue;} 

//mutators 
Color & Color::setRed(unsigned red){ 
    myRed = okColor(red); 
    return *this; 
} 

Color & Color::setGreen(unsigned green){ 
    myGreen = okColor(green); 
    return *this; 
} 

Color & Color::setBlue(unsigned blue){ 
    myBlue = okColor(blue); 
    return *this; 
} 

//output 
const Color & Color::output() const{ 

    cout << "<" << myRed << "," << myGreen << "," << myBlue << ">" << endl; 
    return *this; 
} 

//checkers 
unsigned Color::okColor(unsigned myColor){ 

    if (myColor > 255) { 
     die("Color intensity is out of range!"); 
    } 

    return myColor; 
} 

bool die(const string & msg){ 

    cerr << endl << "Fatal error: " << msg <<endl; 
    exit(EXIT_FAILURE); 
} 

Color mixture(const Color & color0, const Color & color1, double weight){ 

    double color1Multiplier = 0; 
    Color mixture; 
    unsigned mixtureRed; 
    unsigned mixtureBlue; 
    unsigned mixtureGreen; 

    color1Multiplier = 1 - weight; 

    mixtureRed = (color0.getRed() * weight) + (color1.getRed() * color1Multiplier); 
    mixtureBlue = (color0.getBlue() * weight) + (color1.getBlue() * color1Multiplier); 
    mixtureGreen = (color0.getGreen() * weight) + (color1.getGreen() * color1Multiplier); 

    mixture.setRed(mixtureRed); 
    mixture.setBlue(mixtureBlue); 
    mixture.setGreen(mixtureGreen); 

    return mixture; 
} 

Answer 1

Il est simple d'empêcher que votre classe soit appelée depuis le principal. Ne créez pas la classe dans main - aucune classe -> aucun moyen d'appeler les fonctions membres (sauf si elles sont statiques). Vous pouvez également déplacer votre #include de l'en-tête de la classe vers un fichier qui ne se trouve pas dans la même source que main. Malheureusement, il n'y a pas de moyen (trivial et/ou portable) pour déterminer quelle fonction appelle votre code [surtout si nous gardons à l'esprit que les compilateurs modernes bougent souvent le code, donc bien que votre code appelle mixture depuis le principal, le compilateur décide de simplement déplacer cela dans main, parce que cela le rend plus rapide, plus petit ou quel que soit l'autre but que le compilateur a avec les fonctions d'inlining]. Autre que cela, il n'y a aucun moyen d'empêcher une fonction d'être appelée à partir de n'importe quelle fonction qui a accès à l'objet. Pour presque tous les aspects des fonctions, main n'est pas différent des autres fonctions. La seule différence est que main est appelée à partir de la bibliothèque d'exécution C++. Mais le compilateur ne se soucie pas vraiment si votre fonction est appelée main, kerflunk ou fred.

Answer 2

Si vous créez un objet global, il sera initialisé avant main et détruit après main.

Vous pouvez utiliser ce fait pour définir un drapeau et vous comporter comme bon vous semble.