1

我有如下功能：

//Parser.cpp
//...
Parser::Parser(CommandFactory & fact, 
               ArrayList<std::string> & expression)
{

    operations["*"] = &fact.createMultiplyCommand; //error C2276
    operations["/"] = &fact.createAdditionCommand; //error C2276
    operations["+"] = &fact.createAdditionCommand; //error C2276
    operations["%"] = &fact.createModulusCommand; //error C2276
    operations["-"] = &fact.createSubtractionCommand; //error C2276

    infixToPostfix(fact,expression);

}
//...

//Parser.h
//...

    Parser (CommandFactory & fact,
            ArrayList<std::string> & expression);

    Stack<Command*> tempCommandStack;
    ArrayList<Command*> postfix;

    /// Destructor.
    ~Parser (void);

private:
    //syntax is: <return_type> (*)()
    //syntax for a class method is: <return_type> (<class_name> *)();
    //syntax with a typedef is: typedef <return_type> (<class_name> * <typedef_name>)();
    //                          typedef <return_type> (*<typedef_name>)()


    std::map<std::string, Command * (*)()> operations; 
    std::map<std::string,int> precedence;
//...

知道这CommandFactory是一个抽象类也可能会有所帮助（传入的是具体的）

我收到的错误是 C2276: '&' : 对绑定成员函数表达式的非法操作。

当我定义映射时，我不知道我在做什么错。有任何想法吗？

编辑：

//CommandFactory.h
#ifndef _COMMANDFACTORY_H_
#define _COMMANDFACTORY_H_

#include "Subtract.h"
#include "Add.h"
#include "Divide.h"
#include "Multiply.h"
#include "Modulus.h"
#include "Negation.h"
class CommandFactory
{
public:

    virtual Subtract * createSubtractionCommand() = 0;
    virtual Add * createAdditionCommand() = 0;
    virtual Divide * createDivisionCommand() = 0;
    virtual Multiply * createMultiplyCommand() = 0;
    virtual Modulus * createModulusCommand() = 0;
    virtual Negation * createNegationCommand() = 0;
    ~CommandFactory(void);

};

#endif   

//StackCommandFactory.h

#ifndef _STACKCOMMANDFACTORY_H_
#define _STACKCOMMANDFACTORY_H_

#include "Add.h"
#include "Subtract.h"
#include "Divide.h"
#include "Multiply.h"
#include "Modulus.h"
#include "CommandFactory.h"


class StackCommandFactory : public CommandFactory
{
public:



    virtual Subtract * createSubtractionCommand(void);
    virtual Add * createAdditionCommand(void);
    virtual Divide * createDivisionCommand(void);
    virtual Multiply * createMultiplyCommand(void);
    virtual Modulus * createModulusCommand(void);
    virtual Negation * createNegationCommand(void);

protected:
    Subtract * sub;
    Add * add;
    Divide * div;
    Multiply * mul;
    Modulus * mod;
    Negation * neg;

};

#endif   // !defined _STACKCOMMANDFACTORY_H_

//StackCommandFactory.cpp
#include "StackCommandFactory.h"

Subtract * StackCommandFactory::createSubtractionCommand(void)
{
    return sub;
}

Add * StackCommandFactory::createAdditionCommand(void)
{
    return add;
}

Divide * StackCommandFactory::createDivisionCommand(void)
{
    return div;
}

Multiply * StackCommandFactory::createMultiplyCommand(void)
{
    return mul;
}

Modulus * StackCommandFactory::createModulusCommand(void)
{
    return mod;
}

Negation * StackCommandFactory::createNegationCommand(void)
{
    return neg;
}
4

3 回答 3

0

您的代码存在一些问题。主要集中在成员函数的使用而不是全局函数上。您尝试从对象中获取成员函数，而您应该从类本身中获取它们。（即，而不是&fact.createAdditionCommand你需要&CommandFactory::createAdditionCommand。）但这会导致一个未绑定的成员函数，这意味着您需要使用(fact.*fn)()- 即使用 CommandFactory 类的对象来调用它。这并不理想 - 也不是您想要的。您正在寻找绑定的成员函数。在非 C++-11 应用程序中使用这些是可能的，但很难看。您可以使用库来真正提供帮助（除了一些样式更改之外，boost下面的代码几乎不会改变。）如果您使用的是 C++-11，那么您可以使用 C++-11 函数对象。stdboost

这是从您的来源派生的完整示例：

#include <vector>
#include <map>
#include <functional>
#include <string>

struct Command {};
struct Subtract : Command {};
struct Add : Command {};

class CommandFactory
{
  public:

    virtual Subtract * createSubtractionCommand() = 0;
    virtual Add * createAdditionCommand() = 0;
};

class StackCommandFactory : public CommandFactory
{
  public:

    virtual Subtract * createSubtractionCommand(void);
    virtual Add * createAdditionCommand(void);

    Subtract * sub;
    Add * add;
};

Subtract * StackCommandFactory::createSubtractionCommand(void) { return sub; }
Add * StackCommandFactory::createAdditionCommand(void) { return add; }

class Parser
{
  public:
    Parser (CommandFactory & fact);

    std::map<std::string, std::function<Command*()> > operations; 
};

Parser::Parser(CommandFactory & fact)
{
  operations["+"] = std::bind(&CommandFactory::createAdditionCommand, &fact);
  operations["-"] = std::bind(&CommandFactory::createSubtractionCommand, &fact);
}

#include <iostream>
int main()
{
  Add add;
  Subtract sub;

  StackCommandFactory command_factory;
  command_factory.add = &add;
  command_factory.sub= &sub;
  Parser parser(command_factory);

  std::cout<<"&add = "<<&add<<std::endl;
  std::cout<<"Add = " <<  parser.operations["+"]() <<std::endl;
  std::cout<<"&sub = "<<&sub<<std::endl;
  std::cout<<"Sub = " <<  parser.operations["-"]() <<std::endl;

  return 0;
}

我得到输出

&add = 0x7fff58d538d8
Add = 0x7fff58d538d8
&sub = 0x7fff58d538d0
Sub = 0x7fff58d538d0

表明通过解析器返回的 Add 对象与存储在 CommandFactory 中的对象相同。（对于 Subtract 对象也是如此）

于 2013-03-20T05:26:30.350 回答
0

你不能在标准 C++ 中做到这一点。出于原因，请查看此处和此处。

编辑： 与其将“Command * (*)()”存储到操作中，为什么不将“操作”值类型更改为存储“Command *”？或者重新审视底层设计？

于 2013-03-20T03:40:28.023 回答
-1

抱歉试试

操作["*"] = fact.createMultiplyCommand;

或者

操作["*"] = fact->createMultiplyCommand;

于 2013-03-20T01:11:26.903 回答