Estoy tratando de usar usestd :: set_intersection para encontrar elementos comunes entre 2 tipos completamente diferentes de estructuras de datos que tienen un campo de 'nombre' de enlace común.

Miré lo siguienteingrese la descripción del enlace aquí pero parece obligarme a hacer una conversión personalizada entre los 2 tipos de estructura diferentes que estaba tratando de evitar (ya que estos tipos son de un tercero)

El fragmento de código a continuación muestra lo que estoy tratando de lograr.

// common field used for set intersection
typedef struct StructA {
    std::string mCommonField;
    float mFloatValue;
} StructA;

typedef struct StructB {
    std::string mCommonField;
    int mValue1;
    short mValue2;
} StructB;

// 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(),
    [](const StructA& lhs, const StructA& rhs) {
        return lhs.mCommonField < rhs.mCommonField;
    });
std::sort(bStructs.begin(), bStructs.end(),
    [](const StructB& lhs, const StructB& rhs) {
    return lhs.mCommonField < rhs.mCommonField;
});

std::vector<StructA> intersection;
std::set_intersection(
    aStructs.begin(), aStructs.end(),
    bStructs.begin(), bStructs.end(),
    std::back_inserter(intersection),
    [](const StructA& lhs, const StructB& rhs){
        return lhs.mCommonField < rhs.mCommonField;
    });

Estoy usando Visual Studio 2013 para compilar lo anterior, sin embargo, el código anterior arroja una gran cantidad de errores como se muestra a continuación. Leyendo a través delstd :: set_intersection Tengo problemas para armar un dispositivo compatibleStrictWeakOrdering comp último argumento Idealmente me gustaría implementar esto como un único lambda.

template <class InputIterator1, class InputIterator2, class OutputIterator,
          class StrictWeakOrdering>
OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1,
                                InputIterator2 first2, InputIterator2 last2,
                                OutputIterator result, 
                                StrictWeakOrdering comp);

1> C: \ Archivos de programa (x86) \ Microsoft Visual Studio 12.0 \ VC \ include \ Algoritmo (3591): error C2664: 'bool (__vectorcall *) (const main :: StructA &, const main :: StructB &)' : no se puede convertir el argumento 1 de 'main :: StructB' a 'const main :: StructA &' 1>
Motivo: no se puede convertir de 'main :: StructB' a 'const main :: StructA' 1> No hay disponible ningún operador de conversión definido por el usuario que pueda realizar esta conversión, o no se puede llamar al operador 1>
C: \ Archivos de programa (x86) \ Microsoft Visual Studio 12.0 \ VC \ include \ Algoritmo (3625): consulte la referencia a la creación de instancias de plantilla de función '_OutIt std :: _ Set_intersection <_InIt1, _InIt2, _OutIt, _Pr> (_ InIt1, _InIt1, _InIt2 , _InIt2, _OutIt, _Pr) 'se compilan 1> con 1> [1>
_OutIt = std :: back_insert_iterator >> 1>, _InIt1 = main :: StructA * 1>,
_InIt2 = main :: StructB * 1>, _Pr = main :: 1>] 1> C: \ Archivos de programa (x86) \ Microsoft Visual Studio 12.0 \ VC \ include \ Algoritmo (3654): consulte la referencia a la creación de instancias de plantilla de función ' _OutIt std :: _ Set_intersection2 (_InIt1, _InIt1, _InIt2, _InIt2, _OutIt, _Pr, std :: true_type) 'se está compilando 1> con 1> [1>
_OutIt = std :: back_insert_iterator >> 1>, _Pr = main :: 1>, _InIt1 = main :: StructA * 1>,
_InIt2 = main :: StructB * 1>] 1> .... \ src \ dlf \ main.cpp (111): consulte la referencia a la creación de instancias de plantilla de función '_OutIt std :: set_intersection >>, std :: _ Vector_iterator >>, std :: back_insert_iterator >>, main ::> (_ InIt1, _InIt1, _InIt2, _InIt2, _OutIt, _Pr) 'se está compilando 1> con 1> [1>
_OutIt = std :: back_insert_iterator >> 1>, _Ty = main :: StructA 1>,
_InIt1 = std :: _ Vector_iterator >> 1>,
_InIt2 = std :: _ Vector_iterator >> 1>, _Pr = main :: 1>]

También intenté usar una estructura de comparación personalizada para hacer la comparación, pero los errores fueron aún más confusos según:

struct comparator {
    bool operator()(const StructA& lhs, const StructB& rhs) const {
        return lhs.mCommonField < rhs.mCommonField;
    }
    bool operator()(const StructB& lhs, const StructA& rhs) const {
        return lhs.mCommonField < rhs.mCommonField;
    }
};

std::vector<StructA> intersection;
std::set_intersection(
    aStructs.begin(), aStructs.end(),
    bStructs.begin(), bStructs.end(),
    std::back_inserter(intersection),
    comparator());

que dio como resultado la siguiente salida de error detallado. Tenía la esperanza de evitar personalizar las estructuras (ya que las reales que estoy tratando de usar son de un tercero) para tener convertidores de StructA a StructB y viceversa, ¿hay alguna forma de evitar eso y tener un simple lambda? para lograr un enlace simple entre 2 estructuras relativamente simples con un campo común?
Gracias por adelantado.

1> C: \ Archivos de programa (x86) \ Microsoft Visual Studio 12.0 \ VC \ include \ xutility (521): error C2664: 'bool main :: comparator :: operator () (const main :: StructA &, const main: : StructB &) const ': no se puede convertir el argumento 1 de' main :: StructA 'a' const main :: StructB & '1> Motivo: no se puede convertir de' main :: StructA 'a' const main :: StructB '1> No hay disponible ningún operador de conversión definido por el usuario que pueda realizar esta conversión, o el operador no puede llamarse 1> C: \ Archivos de programa (x86) \ Microsoft Visual Studio 12.0 \ VC \ include \ xutility (625): consulte la referencia a la plantilla de función instanciación 'bool std :: _ Debug_lt_pred <_Pr, main :: StructA &, main :: StructA &> (_ Pr, _Ty1, _Ty2, std :: _ Dbfile_t, std :: _ Dbline_t)' se compila 1> con 1> [1>
_Pr = main :: comparator 1>, _Ty1 = main :: StructA & 1>, _Ty2 = main :: StructA & 1>] 1> C: \ Archivos de programa (x86) \ Microsoft Visual Studio 12.0 \ VC \ include \ xutility (636): consulte la referencia a la creación de instancias de plantilla de función 'void std :: _ Debug_order2 <_InIt, _Pr> (_ FwdIt, _FwdIt, _Pr, std :: _ Dbfile_t, std :: _ Dbline_t, std :: forward_iterator_tag)' se está compilando 1> con 1 > [1>
_InIt = std :: _ Vector_iterator >> 1>, _Pr = main :: comparator 1>,
_FwdIt = std :: _ Vector_iterator >> 1>] 1> C: \ Archivos de programa (x86) \ Microsoft Visual Studio 12.0 \ VC \ include \ Algoritmo (3649): consulte la referencia a la instancia de plantilla de función 'void std :: _ Debug_order <_InIt1 , _Pr> (_ InIt, _InIt, _Pr, std :: _ Dbfile_t, std :: _ Dbline_t) 'se compila 1> con 1> [1>
_InIt1 = std :: _ Vector_iterator >> 1>, _Pr = main :: comparator 1>,
_InIt = std :: _ Vector_iterator >> 1>] 1> .... \ src \ dlf \ main.cpp (118): consulte la referencia a la creación de instancias de plantilla de función '_OutIt std :: set_intersection >>, std :: _ Vector_iterator >> , std ::, back_insert_iterator >>, main :: comparator> (_ InIt1, _InIt1, _InIt2, _InIt2, _OutIt, _Pr) 'se compila 1> con 1> [1>
_OutIt = std :: back_insert_iterator >> 1>, _Ty = main :: StructA 1>,
_InIt1 = std :: _ Vector_iterator >> 1>,
_InIt2 = std :: _ Vector_iterator >> 1>, _Pr = main :: comparator 1>] 1> C: \ Archivos de programa (x86) \ Microsoft Visual Studio 12.0 \ VC \ include \ xutility (523): error C2664: 'bool main :: comparator :: operator () (const main :: StructA &, const main :: StructB &) const ': no se puede convertir el argumento 1 de' main :: StructA 'a' const main :: StructB & '1> Motivo : no se puede convertir de 'main :: StructA' a 'const main :: StructB' 1> No hay disponible ningún operador de conversión definido por el usuario que pueda realizar esta conversión, o no se puede llamar al operador 1> C: \ Archivos de programa (x86) \ Microsoft Visual Studio 12.0 \ VC \ include \ xutility (521): error C2664: 'bool main :: comparator :: operator () (const main :: StructA &, const main :: StructB &) const': no se puede convertir el argumento 2 de 'main :: StructB' a 'const main :: StructA &' 1> Motivo: no se puede convertir de 'main :: StructB' a 'const main :: StructA' 1> No hay disponible ningún operador de conversión definido por el usuario que pueda realice esta conversión o no se puede llamar al operador 1> C: \ Archivos de programa (x86) \ Microsoft Visual Studi o 12.0 \ VC \ include \ xutility (625): consulte la referencia a la creación de instancias de plantilla de función 'bool std :: _ Debug_lt_pred <_Pr, main :: StructB &, main :: StructB &> (_ Pr, _Ty1, _Ty2, std :: _ Dbfile_t, std :: _ Dbline_t) 'se está compilando 1> con 1> [1>
_Pr = main :: comparator 1>, _Ty1 = main :: StructB & 1>, _Ty2 = main :: StructB & 1>] 1> C: \ Archivos de programa (x86) \ Microsoft Visual Studio 12.0 \ VC \ include \ xutility (636): consulte la referencia a la creación de instancias de plantilla de función 'void std :: _ Debug_order2 <_InIt, _Pr> (_ FwdIt, _FwdIt, _Pr, std :: _ Dbfile_t, std :: _ Dbline_t, std :: forward_iterator_tag)' se está compilando 1> con 1 > [1>
_InIt = std :: _ Vector_iterator >> 1>, _Pr = main :: comparator 1>,
_FwdIt = std :: _ Vector_iterator >> 1>] 1> C: \ Archivos de programa (x86) \ Microsoft Visual Studio 12.0 \ VC \ include \ Algoritmo (3650): consulte la referencia a la instancia de plantilla de función 'void std :: _ Debug_order <_InIt2 , _Pr> (_ InIt, _InIt, _Pr, std :: _ Dbfile_t, std :: _ Dbline_t) 'se compila 1> con 1> [1>
_InIt2 = std :: _ Vector_iterator >> 1>, _Pr = main :: comparator 1>,
_InIt = std :: _ Vector_iterator >> 1>] 1> C: \ Archivos de programa (x86) \ Microsoft Visual Studio 12.0 \ VC \ include \ xutility (523): error C2664: 'bool main :: comparator :: operator () (const main :: StructA &, const main :: StructB &) const ': no se puede convertir el argumento 2 de' main :: StructB 'a' const main :: StructA & '1> Motivo: no se puede convertir de' main :: StructB 'to' const main :: StructA '1> No hay disponible ningún operador de conversión definido por el usuario que pueda realizar esta conversión, o no se puede llamar al operador