隐式调用operator [C++]

Question

我定义了两个类:

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

第二个:

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_;
};

然后在程序中我有这样的事情:

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.";
    }

}

为什么运算符*()的调用不能隐含？有没有办法让它隐含？谢谢.

Answer 1

token是指向Token_对象的指针,而不是Token_对象本身,因此*switch语句中的运算符仅取消引用指针(从而仅获取对象),但不会继续调用您定义的运算符.

尝试改为:

switch(*(*token)) {

现在使用您的自定义operator *可能有点令人困惑.

另一个选择是更改read_buffer_(),以便您可以执行以下操作:

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

在这种情况下,Token_对象模仿指针,并且通常也不会返回指针指针.