标签: stl-algorithm

我是否正确阅读来自min和max(以及minmax此类)的标准有新的initializer_list变体,但没有Variadic模板变体？

这样就可以了:

int a = min( { 1,2,a,b,5 } );

但这不是:

int b = min( 1,2,a,b,5 ); // err!

我想,很多人都希望Variadic模板可以很容易地实现这一点,因此他们可能会感到失望.

我会说使用VT min并且max会有点矫枉过正

• 可变参数模板能够处理多种类型
• 初始化列表检查所有类型是否相同

因此IL更适合这项任务.

我的解释是否正确？

我有一个类指针向量std::vector<Square*> listSquares.我想用类的一个属性作为关键字对它进行排序.这就是我正在做的事情

bool compById(Square* a, Square* b)
{
    return a->getId() < b->getId();
}

std::sort(listSquares.begin(), listSquares.end(), compById)

但编译器说:错误:没有匹配函数调用'sort(std :: vector :: iterator,std :: vector :: iterator,<unresolved overloaded function type>)'

我在这做错了什么？

我有一个,std::bitset但现在我想在它上面使用STL算法.

我可以使用std::vector<bool>,但我喜欢std::bitset构造函数,我想要std::bitset按位操作.

我是否必须经历一个循环并将所有东西都std::vector<bool>填入使用STL算法,然后将其复制回std::bitset,或者有更好的方法吗？

刚刚意识到std::count_if 返回一个有符号的值.

为什么这样设计？在我看来,这两者都没有意义(结果只能是一个自然数,即非负整数),因为它不允许做一些简单的事情,比如将这个结果与容器进行比较size()而不会得到警告或使用显式类型转换.

我真的认为返回类型应该有size_type.

我错过了什么吗？

为什么有些STL算法提供了额外的'_if'功能而不是重载它？

// example:
find(beg, end, val);
find_if(beg, end, pred);

难道他们只是重载这些算法而不是制作额外的_if功能吗？

我有

using namespace std;
vector<char> tmp;
tmp.push_back(val);
...

现在,当我尝试

transform(tmp.begin(), tmp.end(), tmp.begin(), std::tolower);

它无法编译,但这编译:

transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower);

有什么问题std::tolower？它适用于一个参数,例如std::tolower(56)编译.谢谢!

我写了一些K-nearest-neighbor查询方法,它们构建了一个最接近给定查询点的点列表.为了维护该邻居列表,我使用std::priority_queue了top元素是查询点的最远邻居.这样我知道是否应该推送当前正在检查的新元素(如果距离当前最远的邻居的距离较小),并且当我的优先级队列具有多于K个元素时,可以弹出()最远的元素.

到目前为止,一切都很好.但是,当我输出元素时,我想从最接近最远的位置订购它们.目前,我只是从优先级队列中弹出所有元素并将它们放在输出容器上(通过迭代器),这会导致从最远到最近排序的一系列点,因此,我调用std::reverse输出迭代器范围.

举个简单的例子,这里是一个使用优先级队列的线性搜索(显然,我使用的实际最近邻查询方法要复杂得多):

  template <typename DistanceValue,
            typename ForwardIterator,
            typename OutputIterator,
            typename GetDistanceFunction,
            typename CompareFunction>
  inline 
  OutputIterator min_dist_linear_search(ForwardIterator first,
                                        ForwardIterator last,
                                        OutputIterator output_first,
                                        GetDistanceFunction distance,
                                        CompareFunction compare,
                                        std::size_t max_neighbors = 1,
                                        DistanceValue radius = std::numeric_limits<DistanceValue>::infinity()) {
    if(first == last) 
      return output_first;

    typedef std::priority_queue< std::pair<DistanceValue, ForwardIterator>, 
                                 std::vector< std::pair<DistanceValue, ForwardIterator> >,
                                 detail::compare_pair_first<DistanceValue, ForwardIterator, CompareFunction> > PriorityQueue; 

    PriorityQueue output_queue = PriorityQueue(detail::compare_pair_first<DistanceValue, ForwardIterator, CompareFunction>(compare));

    for(; first != last; ++first) {
      DistanceValue d = distance(*first);
      if(!compare(d, radius)) 
        continue;

      output_queue.push(std::pair<DistanceValue, ForwardIterator>(d, first));

      while(output_queue.size() …

我经常发现自己遇到这个问题:给定一个序列,找到k-最小的元素.问题并不那么难,但我正在寻找的是一种"习惯性"的方式来做到这一点既安全又很少错误)并且沟通意图很好.所以最终做的是对序列进行排序,然后取第一个k元素:

std::sort(container.begin(),container.end());
std::vector<T> k_smallest(container.begin(),container.begin() + k);

在我看来这既安全又易于理解,但这里的复杂性是nlogn + k,而不仅仅是n.你们是如何做到这一点的,是否有一种自觉的方式(使用一些模糊的功能)可以提供最佳的复杂性而无需重新实现轮子

问题

请耐心等待,这只是一个例子:

#include <algorithm>
#include <iterator>
struct foo {
    static int my_transform(int x) { return x;}
    static std::vector<int> my_transform(std::vector<int> x){
        std::vector<int> result;            
        std::transform(x.begin(),x.end(),std::back_inserter(result),my_transform);
        return result;
    }
};

我期待发生什么

有两个可能的重载my_transform,但只有一个导致格式良好的模板实例化,而另一个模板实例化是不正确的.我希望丢弃不正确的一个以及上面的编译.

真正发生了什么

 main.cpp:165:75: error: no matching function for call to
 ‘transform(std::vector<int>::iterator, std::vector<int>::iterator, 
 std::back_insert_iterator<std::vector<int> >, <unresolved overloaded function type>)’
   std::transform(x.begin(),x.end(),std::back_inserter(result),my_transform);
                                                               ^

如何解决它

将函数指针转换为正确的类型可以解决歧义并编译:

static std::vector<int> foo::my_transform(std::vector<int> x){
    std::vector<int> result;
    typedef int (*my_transform_t)(int);     
    std::transform(x.begin(),
                   x.end(),
                   std::back_inserter(result),
                   static_cast<my_transform_t>(my_transform));
    return result;
}

问题

究竟是什么阻止了编译器选择"正确"的重载？考虑到只有一个可以导致有效的模板实例化,实际上并不存在歧义.

PS:请注意,这是C++ 98.在C++ 11及更高版本中,使用lambdas可以很容易地避免这个问题(感谢@appleapple指出这一点).

传递空容器的行为是否已std::lower_bound定义？

我检查了cppreference.com和我在网上找到的旧版C++标准,但找不到明确的答案.

该用于cppreference.com文档std::deque::erase了一句

在以下情况下,迭代器首先不需要可解除引用first==last:删除空范围是无操作.

我想念这样的东西std::lower_bound以及其他算法.