To relax the preconditions means to constrain the algorithm implementation more.

Here is a example to illustrate what I want to achieve. I will have to write my own implementation of set_intersection for work, but I think the stl should provide the algorithms as good as possible.

#include <algorithm>
#include <vector>
#include <iostream>
#include <iterator>

int main()
{
    std::vector A{4,1,6,7};
    std::vector B{1,3,4};

    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());

    // needed for current cpp standard
    std::vector<int> C;
    std::set_intersection(A.begin(), A.end(), B.begin(), B.end(), std::back_inserter(C));
    std::copy(C.begin(), C.end(), std::ostream_iterator<int>(std::cout, " "));

    std::cout << std::endl;

    // illegal, input and output overlap, but works, no memory allocation for output
    auto end = std::set_intersection(A.begin(), A.end(), B.begin(), B.end(), A.begin());  
    std::copy(A.begin(), end, std::ostream_iterator<int>(std::cout, " "));

    std::cout << std::endl;
    // restore A 
    A = std::vector{4,1,6,7};
    std::sort(A.begin(), A.end());

    // also illegal, input and output overlap
    end = std::set_intersection(A.begin(), A.end(), B.begin(), B.end(), B.begin());  
    std::copy(B.begin(), end, std::ostream_iterator<int>(std::cout, " "));
    return 0;
}

Am So., 14. Sept. 2025 um 16:46 Uhr schrieb Andre Kostur <andre@kostur.net>:

Perhaps an example of this working? What are you passing in as the OutputIterator? If the algorithm isn’t writing to the OutputIterator while it’s finding elements, then when it finds a missing element, it would have to go back and copy the first how many ever elements that did match. But, the those are InputIterators: you may not be able to rewind those iterators back to the beginning. (Iterators on cin, for example)

It also means that wherever the OutputIterator points at may never have been written to (consider output iterators on cout) in the case that the intersection is all elements of both sequences. The caller would have to compare the result with first1 and first2 to figure out if they got back an iterator to either of the inputs.

On Sun, Sep 14, 2025 at 6:52 AM Peter Neiss via Std-Proposals <std-proposals@lists.isocpp.org> wrote:
The std::set_intersection algorithm forbids overlap of the input ranges with the output range, but if first1 or first2 and result would be equal, the algorithm could still work(see cppreference for possible implementation).
This would allow inplace execution without memory allocation, which is a big plus.
26.8.7.4 set_intersection (wording)
replace: The resulting range does not overlap with either of the original ranges.
with: result may be equal to first1 or first2, otherwise the resulting range does not overlap with either of the original ranges.

PS: I am quite sure my statement is correct and I am not making a fool out of myself. Still confirmation of my claim would be great.

--
Std-Proposals mailing list
Std-Proposals@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals