2

我有以下实用函数将给定的字符串转换为整数。

class convertToInt:public std::unary_function<const char*, int>
{

        public:
                int operator()(const char* cNumber)
                {
                        try
                        {
                                int result = boost::lexical_cast<int>(cNumber);
                                return result;
                        } catch ( boost::bad_lexical_cast& error)
                        {
                                std::cerr << "Error in converting to number "<< error.what() << std::endl;
                                return -1;
                        }
                }

};

当我想实际使用这个实用功能时，我必须执行以下操作。

  convertToInt cStrToInt;
  int iNumberToCheck = cStrToInt(argv[1]);

我只是想知道，有没有办法，我可以直接打电话

int iNumberToCheck = convertToInt(argv[1]);
4

5 回答 5

5

不，它是一个成员函数，需要一个对象才能调用它。您可以改用未命名的临时文件：

int iNumberToCheck = convertToInt()(argv[1]);
于 2013-05-04T18:25:28.417 回答
1

您可以将函数设为静态，以便它不需要实例。调用必须有范围。

您还可以创建临时变量作为较大表达式的一部分（而不是使用命名变量），这可能看起来效率较低，但实际上可能已被编译器优化为相同的东西。

编辑添加：static不适用于 operator()，因此您需要重新设计才能使用该选项。

于 2013-05-04T18:26:13.720 回答
1

如果你知道调用点的函子的名字，那你为什么不把它变成一个函数呢？

int convertToInt(const char* cNumber)
{
    /*...*/
}

int iNumberToCheck = convertToInt(argv[1]);
于 2013-05-04T18:52:49.337 回答
1

只需创建一个静态初始化的全局变量，这有助于避免静态初始化顺序惨败。静态初始化要求类是聚合类型。只需使用大括号来初始化它：

struct convertToIntF
{
    int operator()(const char* cNumber) const
    {
        try
        {
            int result = boost::lexical_cast<int>(cNumber);
            return result;
        } 
        catch ( boost::bad_lexical_cast& error)
        {
            std::cerr << "Error in converting to number "<< error.what() << std::endl;
            return -1;
        }
    }
};

convetToIntF converToInt = {};

现在，如果函数对象存储状态或继承自非聚合类，这将不起作用。然而，在 C++11 中，编写一个可以静态初始化任何默认可构造函数对象的适配器相当简单：

template<class F>
struct static_
{
    template<class... T>
    auto operator()(T && ... x) const -> decltype(F()(std::forward<T>(x)...))
    {
        static F f;
        return f(std::forward<T>(x)...);
    }
};

然后可以这样初始化：

static_<convetToIntF> converToInt = {};
于 2013-05-05T11:16:38.463 回答
0

正如其他人指出的那样，在这个非常简单的情况下，匿名对象可能会正常工作。但是，如果您有一个更复杂的带有状态的类，请考虑单例模式：

class SingletonFunctor
{
    private:

        // some private state

        // for a hybrid approach, the constructor could be public
        SingletonFunctor()
        {
            // initialize state
        }

     public:

        static const SingletonFunctor& GetSingleton()
        {
            static const SingletonFunctor _singleton;

            return _singleton;
        }

        SomeType operator() (SomeOtherType param) const
        {
            // do something interesting
        }            
};

int main (void)
{
    SomeType firstVal = SingletonFunctor::GetSingleton()(SomeOtherType());

    // ...
    // later

    // no need to instantiate another object
    SomeType secondVal = SingletonFunctor::GetSingleton()(SomeOtherType());
}

如果您改变状态，请小心这种模式，它可能会遇到与全局变量相同的问题（尤其是多线程）。

于 2013-05-05T02:18:18.700 回答