Rendre un opérateur surchargé en C++ un pointeur de fonction

Question

Existe-t-il un moyen de surcharger un opérateur (en particulier, operator >>) en tant que pointeur de fonction, puis lui affecter une fonction lors de l'exécution? Je veux être capable de regarder un fichier à l'exécution pour déterminer le format du fichier, puis affecter le bon pointeur de fonction à l'opérateur pour le faire fonctionner comme désiré. J'attribuerais la fonction correcte au constructeur, avant que l'opérateur ne soit appelé. Je me rends compte qu'il existe d'autres moyens (peut-être plus faciles) de faire la même chose, mais je me demande si c'est possible.

Voici ce que j'ai essayé:

bool Flag; // In global scope - set in main() 

class MyClass 
{ 
private: 
    int data; 
    friend istream & function1(istream & in, MyClass & c); 
    friend istream & function2(istream & in, MyClass & c); 
public: 
    MyClass() :data(0) {operator>>=((Flag)?&function1:&function2);} 
    friend istream& (*operator>>)(istream & in, C & c); 
}; 

// function1 and function2 definitions go here 

int main (int argc, char **argv) 
{ 
    if (argc > 2) 
     Flag = ((atoi(argv[1]) > 1) ? 1 : 0); 
    MyClass mcInstance; 
    ifstream in(argv[2]); 
    in >> mcInstance; 
    return 0; 
} 

je reçois une erreur qui ressemble à ceci:

error: declaration of ‘operator>>’ as non-function

Answer 1

Vous ne pouvez pas redéfinir le sens de toute fonction réelle, y compris les opérateurs, à run-time directement: les fonctions sont des entités immuables. Ce que vous pouvez faire, cependant, est de déléguer dans la fonction, y compris un opérateur défini par l'utilisateur, à une fonction différente en utilisant un pointeur sur une fonction. Par exemple:

std::istream& 
std::operator>> (std::istream& in, MyClass& object) { 
    return Flag? function1(in, object): function2(in, object); 
} 

Si vous souhaitez déléguer par un pointeur de fonction, par exemple, par objet, vous pouvez définir le pointeur de fonction dans votre objet et déléguer par ce qui suit:

class MyClass { 
    fried std::istream& operator>> (std::istream&, Myclass&); 
    std::istream& (*d_inputFunction)(std::istream&, MyClass&); 
public: 
    MyClass(): d_inputFunction(Flag? &function1: &function2) {} 
    // ... 
}; 
std::istream& operator>> (std::istream& in, MyClass& object) { 
    return (object.d_inputFunction)(in, object); 
}