C++ 我可以在编译时强制执行此运算符调用计数要求吗？

我有一个类，就接口而言，它很简单，如下所示：

struct Foo
{
    inline Foo & operator << (int i)
    {
        return *this;
    }
};

---

为什么不使用类似于

FooPair

的工具来增强均匀性：

struct FooPair
{
  int m_x, m_y;

  FooPair(int x, int) : m_x(x), m_y(y)
  {
  }
};

以及：

---

inlinefoo&operator您可以使用模板代理，将状态编码为模板参数，而不是成员

但是，除非对某些内容使用最终返回值，否则只能检查某些条件，而不能检查其他条件。例如，您可以检查一个int是否在float之前插入，或者一行中没有插入两个float，但无法检查int是否在任何float之后插入

通常，您可以通过简单地将插入运算符专门化为无效状态的无效内容来检测在下一次插入之前必须满足的任何条件。但您无法检查最终状态，因为所有代理都必须是可销毁的（每个代理都不同，因此所有中间代理都将被销毁）。
为什么要重新创建
std:：pair
？@Sean，因为这不是我要解决的问题。我将添加其他示例。请提供预期的用例，就目前情况而言，Sean的答案没有理由不起作用。您是否愿意为函数调用牺牲运算符语法？您是否必须支持C++03？如果你能使用C++11，那么你应该使用可变函数模板。这正是我目前正在做的，我希望有一个技巧我可能忽略了。我之所以接受这个答案，是因为在这种特殊情况下，“你做不到”比“用另一种方式做”对我更有用。谢谢
struct Foo
{
    inline Foo() : m_count(0) {}

private:
    struct FooProxy
    {
        friend struct Foo;

        inline ~FooProxy();
        inline struct Foo & operator << (int i);

    private:
        inline FooProxy(struct Foo &foo) : m_foo(foo) {}
        struct Foo &m_foo;
    };

public:
    inline FooProxy operator << (int i);

private:
    int m_count;
};

inline Foo::FooProxy Foo::operator << (int i)
{
    ++m_count;
    return FooProxy(*this);
}

inline Foo & Foo::FooProxy::operator << (int i)
{
    ++m_foo.m_count;
    return m_foo;
}

inline Foo::FooProxy::~FooProxy()
{
    assert(m_foo.m_count % 2 == 0);
}

Foo foo;
foo << 1 << 2 << 3 << 4; /* is OK */
foo << 1 << 2 << 3; /* triggers an assert */

foo << 1 << 2 << 3.f << 4.f << 5; /* is OK */
foo << 1 << 2 << 3.f << 4.f; /* illegal because one `int` is needed */

struct FooPair
{
  int m_x, m_y;

  FooPair(int x, int) : m_x(x), m_y(y)
  {
  }
};

inline Foo & operator << (const FooPair &pair)
{
  return *this;
}

Foo foo;
foo << FooPair(1,2) << FooPair(3,4);