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_个对象模仿指针，你也不会正常返回指针指针。

Answer 2

另一个选择是：

Token_* token = read_buffer_();

做的：

Token_& token = *read_buffer_();

隐式调用operator [C ++]

2 个答案: