Làm thế nào để làm việc xung quanh thực tế là std :: function không có toán tử ==?

Question

Vấn đề: Mã sau đây sẽ rất rõ ràng và ngắn gọn, nếu không nhất thiết phải nhanh, không phải là vì nó không biên dịch.

Nó không biên dịch vì bạn không thể so sánh std :: trường hợp hàm với toán tử ==(). Và std :: find() cố gắng làm chính xác điều đó.

Tất nhiên, tôi có thể thực hiện một loại triển khai hoàn toàn khác, nhưng cứng đầu như tôi và thích thú với mã bên dưới, tôi đang tìm kiếm thứ "gần nhất có thể" hoạt động.

Ai có thể cung cấp cho tôi một đoạn mã khá viết lại dưới đây cũng thực hiện điều tương tự?

#include <functional> 
#include <vector> 

typedef std::function<bool(int)> Tester_t; 
typedef std::vector<Tester_t> TesterSet_t; 

bool Test(TesterSet_t &candidates, int foo) 
{ 
    TesterSet_t dropouts; 
    for(auto& tester : candidates) 
    { 
     if(!tester(foo))  
     { 
      droputs.push_back(tester); 
     } 
    } 

    while(!dropouts.empty()) 
    { 
     // The following line is not compiling because std::function has no operator==() 
     TesterSet_t::iterator culprit = 
      std::find(candidates.begin(), candidates.end(), dropouts.back()); 
     candidates.erase(culprit); 
     dropouts.pop_back(); 
    } 
    return !candidates.empty(); 
} 

Answer 1

Như những người khác đã nói, bạn không cần so sánh số std::function cho việc này. Sử dụng tiêu chuẩn C++ cơ sở này có thể là một cách hiệu quả (với độ phức tạp tuyến tính) thực hiện trong hai dòng:

bool Test(TesterSet_t &candidates, int foo) 
{ 
    candidates.erase(std::remove_if(candidates.begin(), candidates.end(), 
     [foo](Tester_t& f){ return !f(foo); }), candidates.end()); 
    return !candidates.empty(); 
} 

Answer 2

Bạn không cần bình đẳng ở đây. Chỉ cần xóa khi bạn đi

for (auto it = candidates.begin(); it != candidates.end();) { 
    if (! (*it)(foo)) { 
     it = candidates.erase(it); 
    } 
    else { 
     ++it; 
    } 
} 
return !candidates.empty(); 

này cũng sẽ được nhanh hơn so với phiên bản trong câu hỏi thậm chí nếu operator== được định nghĩa cho std::function.

Answer 3

Nếu bạn đã bao giờ không cần phải xóa các ứng cử viên bạn có thể viết:

bool Test(TesterSet_t &candidates, int foo) 
{ 
    return std::any_of(candidates.begin(), candidates.end(), [&foo](Tester_t &tester) { 
     return tester(foo); 
    }); 
} 

CẬP NHẬT

Okay, bạn cần phải loại bỏ các ứng cử viên

bool Test(TesterSet_t &candidates, int foo) 
{ 
    candidates.erase(
     std::remove_if(candidates.begin(), candidates.end(), [&foo](Tester_t &tester) { 
      return !tester(foo); 
     }), 
     candidates.end() 
    ); 
    return !candidates.empty(); 
} 

Answer 4

Câu trả lời đơn giản là không sử dụng std::function<...> trong trường hợp này mà là một cái gì đó giống như std::function<...> mà không xác định một nhà khai thác bình đẳng. Cách tiếp cận để xác định toán tử bình đẳng cho function<...> là phát hiện khi xây dựng liệu đối tượng hàm thực sự có chứa toán tử bình đẳng không và nếu có, làm cho đối tượng có thể so sánh được. Nếu không, bạn hoặc là sẽ tạo ra một lỗi hoặc bạn sẽ xem xét các đối tượng đang nắm giữ kiểu đối tượng hàm đặc biệt này để không thể so sánh được.

Quan sát ngay lập tức là, tuy nhiên, hầu hết các đối tượng hàm không thể so sánh được! Ví dụ, hàm lambda không thể so sánh được và std::bind() và std::mem_fn() cũng không thể tạo ra các đối tượng hàm có thể so sánh được. Một lần nữa, có thể triển khai tùy chỉnh cho std::bind() và std::mem_fn(). Không có cách nào để làm cho hàm lambda có thể so sánh được trừ khi có một lần chụp trống trong trường hợp chúng có thể được chuyển thành con trỏ hàm và có thể được so sánh.

Việc thực hiện các đối tượng chức năng nhận thức bình đẳng là một chút quá dài để nhanh chóng nhập vào phản hồi. Tuy nhiên, bạn có thể xem xét triển khai của tôi tại github để so sánh bình đẳng bind() và mem_fn(). Xem this answer để triển khai phiên bản so sánh bình đẳng của std::function<...>. Nó có thể được mong muốn để có chức năng lambda có thể so sánh, quá, nếu họ có chữ ký giống nhau và tất cả các giá trị bị bắt là bình đẳng so sánh.

Tất cả những gì đã nói, nếu bạn có thể tránh được sự cần thiết, điều đó có lẽ là tốt nhất nên tránh. Tuy nhiên, tôi đã đi qua một số trường hợp sử dụng khi so sánh std::function<...> sẽ khá tiện dụng mặc dù hạn chế của nó (nghĩa là, không phải tất cả các đối tượng chức năng sẽ được đề cập).