#include<vector>
#include<algorithm>
#include<string>
struct StructC {
std::string mCommonField;
int mFloatValue; // cherry picked from StructA
short mValue2; // // cherry picked from StructB
};
// common field used for set intersection
struct StructA {
std::string mCommonField;
float mFloatValue;
operator StructC() { return {mCommonField, int(mFloatValue), 0}; }
};
struct StructB {
std::string mCommonField;
int mValue1;
short mValue2;
operator StructC() { return {mCommonField, 0, mValue2}; }
};
#include <iostream>
#include <iterator>
template<typename CharT, typename Traits>
std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, StructA const& sa) {
return os << sa.mCommonField << " - " << sa.mFloatValue << std::endl;
}
template<typename CharT, typename Traits>
std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, StructC const& sa) {
return os << sa.mCommonField << " - " << sa.mFloatValue << " - " << sa.mValue2 << std::endl;
}
int main() {
struct Common {
std::string const& mCommonField;
Common(StructA const& sa) : mCommonField{sa.mCommonField} {};
Common(StructB const& sb) : mCommonField{sb.mCommonField} {};
};
auto cmp = [](Common const& lhs, Common const& rhs) { return lhs.mCommonField < rhs.mCommonField; };
// initially unsorted list
std::vector<StructA> aStructs = {{"hello", 1.0f}, {"goodbye", 2.0f}, {"foo", 3.0f}};
// initially unsorted list
std::vector<StructB> bStructs = {{"hello", 1, 2}, {"goodbye", 3, 4}, {"bar", 5, 6}};
// sorting both sets before calling std::intersection
std::sort(aStructs.begin(), aStructs.end(), cmp);
std::sort(bStructs.begin(), bStructs.end(), cmp);
std::vector<StructC> union_intersection;
std::set_intersection(aStructs.begin(), aStructs.end(),
bStructs.begin(), bStructs.end(),
std::back_inserter(union_intersection),
cmp);
std::copy(union_intersection.begin(), union_intersection.end(),
std::ostream_iterator<StructC>(std::cout, ""));
return 0;
}
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