C++ 为私有结构定义双参数运算符重载

我试图重载一个操作符，使私有结构的容器只在类中使用（将

std:：deque

与

std:：vector

与

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();
}

#包括
#包括
#包括
#包括
课堂示例1{
公众：
结构S1{
布尔旗；
无符号值；
S1（常量无符号值）：
标志（假）、值（值）
{
//空的
}
布尔运算符==（常数S1和rhs）常数{
返回标志==rhs.flag&&value==rhs.value；
}
};
静态孔隙试验（）；
};
内联布尔运算符==（常数std:：deque&d，常数std:：vector&v）{
返回d.size（）==v.size（）&&std:：equal（d.begin（），d.end（），v.begin（））；
}
内联布尔运算符==（常数std:：vector&v，常数std:：deque&d）{
返回d==v；
}
void Example1:：test（）{
std：：向量v1{1,2,3,4}；
std：：deque d1{1,2,3,4}；
std:：cout您当前的尝试试图重载
Example2:：operator=
，这是两个参数无法做到的

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

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;
}

friend bool操作符==（常数std:：deque&d，常数std:：vector&v）{
返回d.size（）==v.size（）&&std:：equal（d.begin（），d.end（），v.begin（））；
}
友元布尔运算符==（常数std:：vector&v，常数std:：deque&d）{
返回d==v；
}

这将把函数定义为非成员函数。
您当前的尝试试图重载
Example2:：operator=
，这是使用两个参数无法做到的

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

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;
}

friend bool操作符==（常数std:：deque&d，常数std:：vector&v）{
返回d.size（）==v.size（）&&std:：equal（d.begin（），d.end（），v.begin（））；
}
友元布尔运算符==（常数std:：vector&v，常数std:：deque&d）{
返回d==v；
}

这将把函数定义为非成员函数。
您可以使用友谊：

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;
}

friend bool操作符==（常数std:：deque&d，常数std:：vector&v）{
返回d.size（）==v.size（）&&std:：equal（d.begin（），d.end（），v.begin（））；
}
友元布尔运算符==（常数std:：vector&v，常数std:：deque&d）{
返回d==v；
}

你可以使用友谊：

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;
}

friend bool操作符==（常数std:：deque&d，常数std:：vector&v）{
返回d.size（）==v.size（）&&std:：equal（d.begin（），d.end（），v.begin（））；
}
友元布尔运算符==（常数std:：vector&v，常数std:：deque&d）{
返回d==v；
}

有意义，假设重载不能有此处所示的
常量限定符？有意义，假设重载不能有此处所示的
常量限定符？