Skip to content
TheChatArchiveThe Chat Archive
o3-mini· OpenAIHugging Face LMArena Human Preference 140K

no matching function for call to object of type 'const _setintersectionfn'gcc auto…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-flash’s answer.
  1. User

    no matching function for call to object of type 'const __set_intersection_fn'gcc auto find_common_keys(const std::unordered_map<vec3i, std::tuple<vec3f, int>>& map1, const std::unordered_map<vec3i, std::tuple<vec3f, int>>& map2) { std::vector result; std::ranges::set_intersection( map1 | std::views::keys, map2 | std::views::keys, std::back_inserter(result)); return result; }

  2. Assistant

    The error

    no matching function for call to object of type 'const __set_intersection_fn'
    

    typically occurs because std::ranges::set_intersection expects its input ranges to be sorted. In your code, you're taking the keys of two std::unordered_map objects, and the ranges produced by

    map1 | std::views::keys
    map2 | std::views::keys
    

    are not sorted (and indeed, the order in an unordered map is, by definition, unordered).

    There are a couple of ways to resolve this:


    Option 1. Copy and sort the keys first

    If you want to use std::ranges::set_intersection, you need to extract the keys into containers (e.g., vectors), then sort them before computing the intersection. For example:

    #include <algorithm>
    #include <ranges>
    #include <vector>
    #include <unordered_map>
    #include <tuple>
    
    // Assuming vec3i and vec3f are defined appropriately and that vec3i has operator< defined.
    
    auto find_common_keys(const std::unordered_map<vec3i, std::tuple<vec3f, int>>& map1,
                          const std::unordered_map<vec3i, std::tuple<vec3f, int>>& map2) {
        std::vector<vec3i> keys1, keys2;
        keys1.reserve(map1.size());
        keys2.reserve(map2.size());
    
        // Extract keys from map1
        for (const auto& [key, value] : map1) {
            keys1.push_back(key);
        }
        // Extract keys from map2
        for (const auto& [key, value] : map2) {
            keys2.push_back(key);
        }
        
        // Sort the key vectors
        std::ranges::sort(keys1);
        std::ranges::sort(keys2);
        
        // Compute the sorted intersection
        std::vector<vec3i> result;
        std::ranges::set_intersection(keys1, keys2, std::back_inserter(result));
        
        return result;
    }
    

    Notes:

    • This solution assumes that vec3i has an ordering (i.e., an operator<) defined.
    • Extracting and sorting the keys might have performance implications, but it meets the requirements of std::ranges::set_intersection.

    Option 2. Use an unsorted approach

    If you want to avoid sorting because the cost is too high or you don't have an ordering for vec3i, you can compute the intersection by, for example, iterating over one map and checking membership in the other:

    #include <vector>
    #include <unordered_map>
    #include <tuple>
    
    auto find_common_keys(const std::unordered_map<vec3i, std::tuple<vec3f, int>>& map1,
                          const std::unordered_map<vec3i, std::tuple<vec3f, int>>& map2) {
        std::vector<vec3i> result;
        // Iterate over map1's keys and check if each exists in map2.
        for (const auto& [key, value] : map1) {
            if (map2.contains(key)) {  // requires C++20; for older C++ use: if(map2.find(key) != map2.end())
                result.push_back(key);
            }
        }
        return result;
    }
    

    This method leverages the fast average-case lookup of an unordered map and does not require sorting, but the resulting order of keys in result is unspecified.


    Summary

    • Why the error?
      std::ranges::set_intersection expects sorted ranges. The keys directly obtained from an std::unordered_map (or when using std::views::keys) are not sorted, hence no matching function overload can be found for unsorted ranges.

    • How to fix?
      Either sort the keys first (as in Option 1) or use a different intersection algorithm that does not require sorted inputs (as in Option 2).

    Choose the approach that best fits your performance and design requirements.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.