Question

为了优化下面的代码，在我看来，如果我可以将一个指向成员函数str1和str2的指针作为{{{1}的参数传递将是有益的。 1}}而不是在fill_vec中有两个显式循环。

在C ++ 11中有没有首选方法？或者你建议采用不同的策略？

fill_vec

Answer 1

建议的做法将规定fill_vec()应该是Base的成员，最好从构造函数调用，因此该对象可以在创建后立即使用。

但是，由于映射m_base1和m_base2是常量，因此您应该取消m_str1和m_str2，使m_base1和m_base2静态并在构造函数中直接初始化它们。

而且，你应该尽可能使用智能指针。

这给出了：

#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <memory>

class Base
{
  private:
    static std::map<int, std::string> m_base1, m_base2;

  public:
    Base();  // WARNING !! must create a object before using maps!

    static const auto & base1() { return m_base1; }
    static const auto & base2() { return m_base2; }
};


// in base.cpp

std::map<int, std::string> Base::m_base1;

Base::Base()
{
    if (m_base1.empty())
    {
        m_base1[0] = "one";
        m_base1[1] = "two";
        m_base1[2] = "three";
    }
    if (m_base2.empty())   
    {
        m_base2[0] = "four";  // doesn't look right, but equivalent to original code
        m_base2[1] = "five";
        m_base2[2] = "six";
    }
}


// in your main module..

int main(int argc, char *argv[])
{
    // auto b = std::unique_ptr<Base>(new Base{});
    // this would be best since Base is very small.
    Base b;

    // this prints the string "two six"
    std::cout << b.base1().at(1) << " " << b.base2().at(2) << '\n';

    return 0;
}

Answer 2

这是可能的，但我会根据上述评论检查它的实用性。

这样的事情会起作用：

template <typename T>
void fill_vec(Base* obj, std::map<int, std::string>& (T::*mapv)(), std::vector<std::string>& (T::*vec)())
{
    size_t counter = 0;
    for (const auto &str_iter : (obj->*vec)())
        (obj->*mapv)()[counter++] = str_iter;       
}

int main(int argc, char *argv[])
{
    Base *b = new Base;
    fill_vec(b, &Base::base1, &Base::str1);

    return 0;
}

这与您通常传递pointer to member fields

的方式类似

使用C ++ 11将指向成员函数的指针作为参数传递

2 个答案: