相关疑难解决方法(0)

我有一组由整数类型Index和类类型模板化的函数,T我以下列方式"部分地专门化":

// Integer type
enum Index{One,Two,Three,Four};

// Default implementation
template<int I>
struct Foo{
  template<typename T> static void bar(const T& x){ std::cout <<"default" << endl; }
};

// Template specializations
template<> 
struct Foo<One>{
  template<typename T> static void bar(const T& x){ std::cout << "one" << endl; }
};

这用于在程序的运行时使用switch语句选择一个特定的索引(这应该会产生一个高效的查找表).该开关独立于T:

template<typename T>
void barSwitch(int k, const T& x){
  switch(k){
    case ONE: Foo<ONE>::bar(x); break;
    case TWO: Foo<TWO>::bar(x); break;
    case THREE: Foo<THREE>::bar(x); break;
  }
}

当然,这很好用,但是这个类Foo并不是我想要应用这个开关的唯一类.事实上,我有很多类都是由相同的整数类型模板化的.所以我想barSwitch …

我确实研究了函子的整个概念，但是不幸的是，我无法理解函子相对于典型函数的真正优势。

根据一些学术脚本，函子可以保持与功能不同的状态。任何人都可以通过一些简单易懂的示例来详细说明吗？

我真的不明白为什么典型的常规功能不能做到这一点。对于这种新手问题，我真的感到很抱歉。

我有兴趣从地图中删除具有特定键的元素并使用此元素.

看起来像:

itr = MyMap.pop(wantedKey);
//Now MyMap is missing the element which has the key 'wantedKey'.
//Do something with this element through 'itr'.

这样做有stl map方法吗？

编辑

在carleeto的回复之后,我想澄清一下:我需要的是从地图中删除的元素以及之后能够使用它的程序,它可以是元素本身作为一对,不一定是迭代器.

我有一个在本地函数中可以正常工作的代码：

struct Divider
{
public:
    size_t factor;
    size_t next;
};

void foo()
{
    auto cmp = [](const Divider& x, const Divider& y) { return x.next > y.next; };
    std::priority_queue < Divider, std::vector<Divider>, decltype(cmp)> sieve(cmp);
    // ...
}

我现在想将我的sieve变量移到一个类中。我可以写出以下怪物：

class Bar
{
    inline static auto cmp = [](const Divider& x, const Divider& y) { return x.next > y.next; };
    std::priority_queue < Divider, std::vector<Divider>, decltype(cmp)> sieve = std::priority_queue < Divider, std::vector<Divider>, decltype(cmp)>(cmp);
};

有什么方法可以编写这种默认构造而无需两次指定类型？或者只是以一种更清洁的方式。

我正在尝试将 C++ flex 与 C++ bison 连接起来，但我被难住了。Bison 3.8.1 手册有一个带有 C Flex 的 C++ Bison 示例。Flex 2.6.4 没有示例。我试图解决的问题是如何向 C++（或 C）Bison 提供指向 C++ Flex 对象的实例指针。我最好的想法是定义YY_DECL要使用的 Flex 扫描器# define YY_DECL bison::symbol_type flx->yylex()，并通过解析器调用序列将 flx 传递到 Bison，重新定义“解析”。这样对吗？还有更好的方法吗？

考虑以S-expr表示法编写的以下代码段:

(lambda (x) (lambda (y) (+ x y)))

或者在Javascript中:

function(x) { return function(y) { return x+y; }; }

我怎么用C写这个？

bool comp(const pair<int, int>& a, const pair<int,int>& b){
    if (v[a.first]>v[b.first]) {
        return true;
    }
    else if(v[a.first] == v[b.first] && a.second < b.second){
        return true;
    }
    return false;
}

所以,我正在通过一个代码,我遇到了这个比较器函数,用于排序对的向量.现在,我对C++很新.我试着阅读关于这个比较器如何工作的其他问题？但我无法理解.为什么返回类型是bool？返回值true意味着什么？

我想std::find在一个shared_ptr抽象类的列表上使用,但我收到一个错误.有没有办法shared_ptr通过解除引用来比较两个std::find？

是否有可能让一个operator==超载的朋友shared_ptr<A>？

最小的例子:

#include "point.h"
#include <list>
#include <algorithm>
#include <memory>

using namespace std;

class A {

protected:
    Point loc;
public:

    virtual void foo() = 0;

    virtual bool operator==(const Point& rhs) const = 0;
};

class B: public A {
    virtual void foo() override{}

    virtual bool operator==(const Point& rhs) const override {
        return rhs == loc;
    }
};

class C {

    list<shared_ptr<A>> l;
    void bar(Point & p) { …

std::less当它只调用<运算符时,为什么需要(和等效的其他函数对象),我们可以反过来运算符？

可能的答案有问题:

为什么std ::比"<"更好？

但是我并不完全相信(特别是关于弱排序).有人可以解释一下吗？

如果在 C++ 中通过复制传递 lambda 函数，实际上会复制什么？

它只是一个指向 lambda 的指针吗？

或者整个捕获列表也会被复制吗？