invocation implicite de l'opérateur [C++]

Question

I défini deux classes:

class Token_ 
{ 
public: 
    virtual char operator*()const = 0;//this fnc cannot run implicitly 
protected: 
    Token_() 
    { } 
    Token_(const Token_&); 
    Token_& operator=(const Token_&); 
}; 

et deuxième:

class Operator : public Token_ 
    { 
    public: 
    Operator(const char ch):my_data_(token_cast<Operator_enm>(ch)) 
    { } 
    Operator_enm get()const 
    { 
     return my_data_; 
    } 
    Operator_enm set(const Operator_enm& value) 
    { 
     Operator_enm old_value = get(); 
     my_data_ = value; 
     return old_value; 
    } 
    char operator*()const//this operator has to be invoke explicitly 
    { 
     return static_cast<char>(my_data_); 
    } 
private: 
    Operator_enm my_data_; 
}; 

et plus tard dans le programme que j'ai quelque chose comme ceci:

template<class R> 
R Calculator::expr_()const 
{ 
    Token_* token = read_buffer_(); 
    switch (*token)//here if I use explicit call of operator*() it works 
    { 
    case PLUS: 
     { 
      R result ;//not defined yet 
      return result; 
     } 
    case MINUS: 
     { 
      R result ;//not defined yet 
      return result; 
     } 
    default: 
     cerr << "Bad expr token."; 
    } 

} 

Pourquoi cet appel de l'opérateur *() ne peut pas être implicite? Y a-t-il un moyen de le rendre implicite? Merci.

Answer 1

token est un pointeur vers un objet Token_, pas un objet Token_ lui-même, donc l'opérateur * dans l'instruction switch déréférence le pointeur seul (ce qui n'obtenir l'objet), mais ne pas alors continuer d'appeler l'opérateur vous défini.

Essayez plutôt:

switch(*(*token)) { 

L'utilisation de votre commande operator * peut être un peu déroutant maintenant bien.

Une autre option consiste à modifier read_buffer_() de telle sorte que vous pouvez effectuer les opérations suivantes:

Token_ token = read_buffer_(); // NOTE: read_buffer_() returns a Token_ object directly 
switch (*token)//here if I use explicit call of operator*() it works 

Dans ce cas, Token_ objets mimer des pointeurs, et vous ne seriez pas retourner un pointeur vers des pointeurs normalement non plus.

Answer 2

L'autre option est au lieu de:

Token_* token = read_buffer_(); 

faire:

Token_& token = *read_buffer_();