Question

我创建了一个使用可链接的Filter和Map操作的类，主要用于避免冗余for循环。

例如

std::vector<ObjectASharedPtr> temp = GetListOfA();
FunctionalIteratableWrapper<ObjectASharedPtr> wrapper( temp );
wrapper.Filter([]( ObjectASharedPtr objA ){ return objA->isApple(); } ).Map([]( ObjectASharedPtr objA ){ return objA->Bite(); })

我的课程的简短版本可以在问题的底部看到，不要用一长段代码来破坏这个问题。

当我将矢量作为＆＃34; std :: vector＆＃34;时，它非常有效。比我可以轻松启动我的包装。

但现在有一个遗留代码，它不直接将数据作为列表提供，而是使用索引：

auto count = LegacyObjList->getCount(); 
for ( int i = 0; i < count; i++ )
    LegacyObj.getObjByIndex(i);

目前每当我想用这种结构实例化我的FunctionalIteratableWrapper时，只允许使用索引访问我需要做的事情：

std::vector<LegacyObj> tempVec;
auto count = LegacyObjList->getCount(); 
for ( int i = 0; i < count; i++ )
    tempVec.push_back(LegacyObj.getObjByIndex(i));

FunctionalIteratableWrapper<LegacyObj> wrapper(temp);

我想避免这个for循环，我现在每次使用这样的对象创建我的包装器，只允许使用索引进行访问。什么应该是最佳解决方案？

template< typename Value >
class FunctionalIteratableWrapper
{
public:


    /*!
     * \brief A copy ctor like ctor. Which initiates this struct directly from vector of Iteratable.
     * \param list vector of Iteratable
     */
    FunctionalIteratableWrapper( const std::vector<Value>& list  )
    {
        iteratableList = list;
    }

    /*!
     * \brief Default ctor
     */
    FunctionalIteratableWrapper()
    {

    }

    template <typename F>
    FunctionalIteratableWrapper& Filter( F filterFunction, bool isReturnOneElement = false )
    {
        std::vector<Value> newList;
        for ( size_t i = 0; i < iteratableList.size(); i++)
        {
            if ( filterFunction(iteratableList[i]) )
            {
                newList.push_back(iteratableList[i]);
                if ( isReturnOneElement )
                   break;
            }
        }
        iteratableList = newList;
        return *this;
    }

,
    template < typename T, typename F >
    T Find( F filterFunction)
    {
        for ( size_t i = 0; i < iteratableList.size(); i++)
        {
            if ( filterFunction(iteratableList[i]) )
                return Cast<typename T::element_type>(iteratableList[i]);
        }
        return T();
    }

    template <typename T, typename F>
    FunctionalIteratableWrapper& Map( F applyFunction)
    {
        for ( size_t i = 0; i < iteratableList.size(); i++)
        {
            auto castedTerrain = Cast<typename T::element_type>(iteratableList[i]);
            if ( castedTerrain )
                applyFunction(castedTerrain);
        }
        return *this;
    }

    void Append( Value newElement )
    {
        iteratableList.push_back( newElement );
    }



    std::vector<Value> iteratableList;
};

Answer 1

处理此问题的简单方法是编写ADL辅助函数。

首先更改构造函数：

FunctionalIteratableWrapper( std::vector<Value> list  ):
  iterableList(std::move(list))
{
}

我们现在支持廉价搬入。

接下来，创建一个名称空间：

namespace my_utility {
  namespace helper1 {
    template<class T, class A>
    std::vector<T, A> to_vector( std::vector<T, A> in ) {
      return std::move(in);
    }
  }
  namespace helper2 {
    using ::my_utility::helper1::to_vector;
    template<class T>
    auto as_vector( T&& t )
    -> decltype( to_vector( std::forward<T>(t) ) )
    {
      return to_vector( std::forward<T>(t) );
    }
  }
  using ::my_utility::helper2::as_vector;
}

现在调用::my_utility::as_vector(x)会在to_vector(x)上执行ADL查找。如果找不到，则会尝试将x推导为std::vector<T,A>并返回副本。

现在我们添加一个构造函数：

template<class T,
  class=std::enable_if_t< !std::is_same< std::decay_t<T>, FunctionalIteratableWrapper >::value >
>
FunctionalIteratableWrapper( T&& t ):
  iterableList(::my_utility::as_vector(std::forward<T>(t))
{
}

我们快到了！

在LegacyObj的命名空间中，写下：

std::vector<LegacyObj> to_vector( LegacyObjList const* pList ) {
  if (!pList _obj) return {};
  std::vector<LegacyObj> retval;
  int size = pList->getCount();
  retval.reserve(size);
  for (int i = 0; i < size; ++i)
    retval.push_back(pList->getObjByIndex(i);
  return retval;
}

它将由as_vector神奇地找到（好吧，使用ADL）。

现在LegacyObjList const*可以隐式转换为FunctionalInterableWrapper。

代码未经测试。您可以先写to_vector，然后手动测试，然后获得99％的费用。

然后执行::my_utility::as_vector技巧。

最后，看看你是否可以获得调用as_vector的构造函数。

每个都增加了价值，可以与其他人分开编写。

从对象创建向量包装器，该对象仅允许访问索引为

1 个答案: