Can you swap a std::queue with a lambda comparator?

Question 1

While the result of a lambda expression is move constructible it isn't necessarily move assignable and certainly not copyable. I would just bypass the problem by using a std::reference_wrapper<decltype(comp)> for the comparator object:

typedef pair<int,float> ifpair;
auto comp = []( ifpair a,  ifpair b ) { return a.second > b.second; };
typedef priority_queue< ifpair , vector<ifpair>,
                        std::reference_wrapper<decltype( comp ) >> t_npq;
t_npq npq( std::ref(comp) );
t_npq empty( std::ref(comp) );
swap(npq , empty);

Since the full type information of the lambda expression is retained by the reference wrapper, this should work even if the closure isn't empty and, where viable, it should be possible to inline the function.

Question 2

As the compile error indicates, lambda objects aren't assignable. You can use a different type of functor for the queue but still write it as a labmda:

Use std::function<bool(ifpair,ifpair)>: http://ideone.com/HZywoV

But this adds (probably noticable) overhead due to some more indirections in the implementation of std::function but I guess this heavily depends on the implementation of the standard library and the compiler optimizations. Might be the nicest solution regarding how the code looks though.
Use a function pointer bool(*)(ifpair,ifpair): http://ideone.com/ZhFq3C

This should not suffer from any overhead compared to std::function but to your current solution, since there might be some compiler optimizations done to your lambda code which are then not possible (i.e. inlining it into the rest of the std::queue code which for example eliminates copying the two pairs). Using function pointers looks pretty old-school though.
Use a custom functor class which can be as simple as: http://ideone.com/9pcQFc
```
template<typename Pair>
struct GreaterBySecond {
    bool operator()(Pair a, Pair b) const {
        return a.second > b.second;
    }
};
```
This should eliminate all overhead discussed above. I'd prefer this if performance matters.

Question 3

Have you tried to use std::function?

#include <queue>
#include <vector>
#include <functional>
using namespace std;
int main(){
    typedef pair<int,float> ifpair;
    std::function< bool ( ifpair, ifpair )> comp = []( ifpair a,  ifpair b ) { return a.second > b.second; };
    typedef priority_queue< ifpair , vector<ifpair>, decltype( comp ) > t_npq;
    t_npq npq( comp );
    //do something with npq. finish using it (without emptying it) and clear for next round
    t_npq empty( comp );
    swap(npq , empty);
}

Question 4

Lambdas aren't assignable – 5.1.2/19:

The closure type associated with a lambda-expression has a deleted default constructor and a deleted copy assignment operator.

The swap of the containers wants to assign the comparators, too, so that doesn't work.

However, you can easily make it work by converting the stateless lambda to a function pointer first:

bool (*p)(ifpair, ifpair) = [](ifpair a, ifpair b) { return a.second > b.second; };

Now use:

priority_queue<ifpair, vector<ifpair>, bool(*)(ifpair, ifpair)>

(You might want to introduce a typedef for the function type: using comp_type = bool(iftype, iftype), and then use comp_type * everywhere.)