c++ - 非法表达式和 const_Hasher 丢失

Question

有人可以向我解释为什么会出现这两个错误吗？

该错误表明 C2056: 非法表达式和错误 C3849: 函数样式调用类型为“const _Hasher”的表达式将丢失所有 2 个可用运算符重载的 const 和/或 volatile 限定符

我在这里遗漏了一些部分吗？

一些未知的错误出来了。有人可以解决这个问题吗？

class myCompareClass {
    //For all comparions, compare the sums of all int objects in the structures.
    //For Hashing function use h(sums int in the sturcture), where hash<int> h;
public:
    bool operator()(int* p1, int* p2) const { return *p1 < *p2; }//set
    bool operator()(list<set<int*, myCompareClass>*>* p1, list<set<int*, myCompareClass>*>* p2) {
        int sum1{ 0 }, sum2{ 0 };
        for (auto i : *p1) {
            for (auto j = *i->begin(); j != *i->end(); i++) {
                sum1 += *j;
            }
        }

        for (auto i : *p2) {
            for (auto j = *i->begin(); j != *i->end(); i++) {
                sum2 += *j;
            }
        }

        return sum1 < sum2;
    }
    bool operator() (const map < list<set<int*, myCompareClass>*>*, vector<int*>*, myCompareClass >& M1,
        const map < list<set<int*, myCompareClass>*>*, vector<int*>*, myCompareClass >& M2)  const {
        int sum1{ 0 }, sum2{ 0 };
        for (auto i : M1) {
            auto& L = *i.first;
            auto& R = *i.second;
            for (auto a:L)
            {
                for (auto w : *a) {
                    sum1 += *w;
                }
            }
            for (auto e : R) {
                sum1 += *e;
            }
        }
        
        for (auto i : M2) {
            auto& L = *i.first;
            auto& R = *i.second;
            for (auto a : L)
            {
                for (auto w : *a) {
                    sum2 += *w;
                }
            }
            for (auto e : R) {
                sum2 += *e;
            }
        }

        return sum1 < sum2;

    }
};

class myCompareClass1 {
    //Need a functor for ==
    //For Hashing function use h(sums int in the sturcture), where hash<int> h;
public:

    bool operator() (const map < list<set<int*, myCompareClass>*>*, vector<int*>*, myCompareClass >& M1,
        const map < list<set<int*, myCompareClass>*>*, vector<int*>*, myCompareClass >& M2)  const {
        int sum1{ 0 }, sum2{ 0 };
        for (auto Q = M1.begin(); Q != M1.end(); Q++) {
            auto& W = Q->first;
            auto& E = Q->second;
            for (auto R = *W->begin(); R != *W->end(); R++) {
                for (auto T = *R->begin(); T != *R->end();T++) {
                    sum1 += *T;
                }
            }

        }

        for (auto Q = M2.begin(); Q != M2.end(); Q++) {
            auto& W = Q->first;
            auto& E = Q->second;
            for (auto R = *W->begin(); R != *W->end(); R++) {
                for (auto T = *R->begin(); T != *R->end(); T++) {
                    sum2 += *T;
                }
            }

        }
        return sum1 == sum2;

    }

    size_t operator()(const map < list<set<int*, myCompareClass>*>*, vector<int*>*, myCompareClass >& M1) {
        int sum{ 0 };
        for (auto i : M1) {
            auto& Q = i.first;
            auto& W = i.second;
            for (auto E : *Q) {
                for (auto R : *E) {
                    sum += *R;
                }
            }
            for (auto T : *W) {
                sum += *T;
            }
        }
        hash<int> h;
        return h(sum);

    }
};
//You need to implement overloaded operator<< .

ostream& operator<< (ostream& str, const set<map < list<set<int*, myCompareClass>*>*, vector<int*>*, myCompareClass >, myCompareClass>& S) {
    str << "<";
    for (auto i = S.begin(); i != S.end(); i++) {
        str << "{";
        for (auto q : *i) {
            str << "[";
            auto w = q.first;
            auto e = q.second;
            for (auto a : *w) {
                str << "<";
                for (auto s : *a) {
                    str << *s << " ";
                }
                str << ">";
            }
            str << "]";
            str << "(";
            for (auto p : *e) {
                str << *p << " ";
            }
            str << ")";
        }
        str << "}";
    }
    str << ">";
    return str;
}

ostream& operator<< (ostream& str, const unordered_set< map < list<set<int*, myCompareClass>*>*, vector<int*>*, myCompareClass >, myCompareClass1, myCompareClass1>& H) {
    str << "<";
    for (auto i : H) {
        str << "{";
        for (auto a : i) {
            auto& Q = a.first;
            auto& W = a.second;
            str << "[";
            for (auto E : *Q) {
                str << "<";
                for (auto R : *E) {
                    str << *R << " ";
                }
                str << ">";
            }
            str << "]";
            str << "(";
            for (auto T : *W) {
                str << *T << " ";
            }
            str << ")";
        }
        str << "}";
    }
    str << ">";
    return str;
}

int main() {

    set<map < list<set<int*, myCompareClass>*>*, vector<int*>*, myCompareClass >, myCompareClass> S{
            {
                    {new list<set<int*, myCompareClass>*>
                    {new set<int*, myCompareClass>
                    {new int{10},new int{20} ,new int {30}}}, new vector<int*>{new int{10},new int{20},new int {30}}},
                    {new list<set<int*, myCompareClass>*>
                    {new set<int*, myCompareClass>
                    {new int{10},new int{20}, new int {30}}}, new vector<int*>{new int{10},new int{20},new int {30}}}
            },
            {
                    {new list<set<int*, myCompareClass>*>
                    {new set<int*, myCompareClass>
                    {new int{10},new int{20}, new int {30}}}, new vector<int*>{new int{10},new int{20},new int {30}}},
                    {new list<set<int*, myCompareClass>*>
                    {new set<int*, myCompareClass>
                    {new int{10},new int{20}, new int {30}}}, new vector<int*>{new int{10},new int{20},new int {30}}}
            }
    };

    cout << S << endl;
    unordered_set< map < list<set<int*, myCompareClass>*>*, vector<int*>*, myCompareClass >, myCompareClass1, myCompareClass1> H{
                {
                        {new list<set<int*, myCompareClass>*>
                        {new set<int*, myCompareClass>
                        {new int{10},new int{20},new int {30}}}, new vector<int*>{new int{10},new int{20},new int {30}}},
                        {new list<set<int*, myCompareClass>*>
                        {new set<int*, myCompareClass>
                        {new int{10},new int{20},new int {30}}}, new vector<int*>{new int{10},new int{20},new int {30}}}
                },
                {
                        {new list<set<int*, myCompareClass>*>
                        {new set<int*, myCompareClass>
                        {new int{10},new int{20},new int {30}}}, new vector<int*>{new int{10},new int{20},new int {30}}},
                        {new list<set<int*, myCompareClass>*>
                        {new set<int*, myCompareClass>
                        {new int{10},new int{20},new int {30}}}, new vector<int*>{new int{10},new int{20},new int {30}}}
                }
    };
    cout << H << endl;
    return 0;
}

标签： c++