Question

这个问题有趣，我知道我无法定义operator_。

但是，我真的喜欢“弯曲”此规则，将以下内容视为有效（有效被松散定义！）。

T result = somevar _ someother;

我没有找到可能的解决方案，但也许你可以，可能使用一些预处理器übertricks。（当然只是#define _ SOMETHING非常危险）

非常感谢任何帮助！

Answer 1

为了好玩，可能会这样吗？

#include <iostream>


struct _magic_
{
};

template<class T>
  struct enchanted
  {
    enchanted(T t) : value(t) {}
    T value;
  };

static constexpr auto _ = _magic_{};

template<class T>
enchanted<T> operator| (T&& t, _magic_ magic)
{
  return {std::forward<T>(t)};
}

template<class T, class U>
auto operator| (const enchanted<T>& e, U u)
{
  return e.value + u;
}

int main()
{
  int x = 4;
  int y = 5;
  auto z = x |_| y;

  std::cout << z << std::endl;
}

Answer 2

这个怎么样：

#include <iostream>

struct Underscore {};
#define _ | Underscore() |

template<typename T>
struct Has
{
    const T& m_t;

    Has( const T& t )
    : m_t( t )
    {
    }
};

template<typename T>
Has<T> operator|( const T& lhs, const Underscore& )
{
    return Has<T>( lhs );
}

template<typename T, typename U>
auto operator|( const Has<T>& lhs, const U& rhs )
{
    std::cout << "This is the body of your iterator for " << lhs.m_t << " and " << rhs << std::endl;
    return 0;
}

int main()
{
    const std::string a = "a";
    const std::string b = "b";
    a _ b;

}

强制operator_（下划线）

2 个答案: