Question

我正在尝试重载运算符，以使私有结构的容器仅在类中使用（将std::deque<T>与std::vector<T>与operator==()进行比较）。

我习惯于声明操作符重载，如下所示。

这会像我期望的那样显示“ 1”，但是该结构是公共的。

#include <iostream>
#include <algorithm>
#include <vector>
#include <deque>

class Example1 {
public:
    struct S1 {
        bool flag;
        unsigned value;

        S1(const unsigned value) :
            flag(false), value(value)
        {
            // Empty
        }

        bool operator==(const S1 &rhs) const {
            return flag == rhs.flag && value == rhs.value;
        }
    };

    static void test();
};

inline bool operator==(const std::deque<Example1::S1> &d, const std::vector<Example1::S1> &v) {
    return d.size() == v.size() && std::equal(d.begin(), d.end(), v.begin());
}

inline bool operator==(const std::vector<Example1::S1> &v, const std::deque<Example1::S1> &d) {
    return d == v;
}

void Example1::test() {
    std::vector<S1> v1 { 1, 2, 3, 4 };
    std::deque<S1> d1 { 1, 2, 3, 4 };

    std::cout << (v1 == d1) << "\n";
}

int main() {
    Example1::test();
}

当结构是私有的时，我应该如何定义这些运算符？

我尝试了以下方法。

#include <iostream>
#include <algorithm>
#include <vector>
#include <deque>

class Example2 {
public:
    static void test();
private:
    struct S2 {
        bool flag;
        unsigned value;

        S2(const unsigned value) :
            flag(false), value(value)
        {
            // Empty
        }

        bool operator==(const S2 &rhs) const {
            return flag == rhs.flag && value == rhs.value;
        }
    };

    bool operator==(const std::deque<S2> &d, const std::vector<S2> &v) const {
        return d.size() == v.size() && std::equal(d.begin(), d.end(), v.begin());
    }

    bool operator==(const std::vector<S2> &v, const std::deque<S2> &d) const {
        return d == v;
    }
};

void Example2::test() {
    std::vector<S2> v1 { 1, 2, 3, 4 };
    std::deque<S2> d1 { 1, 2, 3, 4 };

    std::cout << (v1 == d1) << "\n";
}

int main() {
    Example2::test();
}

但是重载只能有一个参数：

main.cpp:25:72: error: ‘bool Example2::operator==(const std::deque&, const std::vector&) const’ must take exactly one argument
     bool operator==(const std::deque<S2> &d, const std::vector<S2> &v) const {

Answer 1

您当前的尝试尝试使Example2::operator==重载，而这不能用两个参数来完成。

简单的解决方案是将这些运算符定义为Example2类的 friends ：

friend bool operator==(const std::deque<S2> &d, const std::vector<S2> &v) {
    return d.size() == v.size() && std::equal(d.begin(), d.end(), v.begin());
}

friend bool operator==(const std::vector<S2> &v, const std::deque<S2> &d) {
    return d == v;
}

这会将这些函数定义为非成员函数。

Answer 2

您可以使用友谊：

friend bool operator==(const std::deque<S2> &d, const std::vector<S2> &v) {
    return d.size() == v.size() && std::equal(d.begin(), d.end(), v.begin());
}

friend bool operator==(const std::vector<S2> &v, const std::deque<S2> &d) {
    return d == v;
}

Demo

为私有结构定义两个参数的运算符重载

2 个答案: