c++ - 如何编写自己的操纵器？

Question

假设我想为输入和输出编写自己的操纵器。

cin >> mymanip >> str;

或者

cout << mymanip << str;

我想要 mymanip 做的是切换我从输入中读取的字符并将结果分配给一个字符串。

所以，如果我输入“QwErTy”，我会在字符串中得到“qWeRtY”。

这是具有一个功能的非常基本的任务，但我想了解更多关于操纵器的信息。

有人可以提供线索吗？

谢谢你。

Answer 1

std::ios_base操纵器所做的只是在基类中设置相应的位。

例如，std::setprecision()操纵器只是在被操纵的流上调用 std::ios_base::precision() 。

的实现std::setprecision()在 gcc 的头文件中几乎是可读的（对于 C++ 库模板实现来说是罕见的）：

 inline _Setprecision  setprecision(int __n)
     { return { __n }; }

std::setprecision()返回一个内部std::_Precision对象。>>然后，对象的（和<<类似的）运算符的简单模板重载std::_Precision处理其余的魔术：

 template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>& 
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
    { 
      __is.precision(__f._M_n); 
      return __is; 
    }

在您的情况下，类中没有位std::ios_base可以实现您所需的输入/输出转换。因此，机械手本身不会在这里工作。

您正在尝试做的事情需要一种完全不同的、更复杂的方法：

1. 的自定义子类std::[io]stream，它使用 的自定义子类std::streambuf。

2. 子类从链式流中std::streambuf读取或写入，如您所描述的那样转换输入或输出。

3. 从自定义子类读取或写入最终会从链式流中读取或写入，从而相应地转换数据。

Answer 2

方法有点棘手 - 但可以做到，您可以为流添加自己的操纵器。

首先，您需要切换：

class toggle_t {};
constexpr toggle_t toggle;

接下来 - 的版本ostream（情况istream非常相似......）：

放入toggle后ostream- 你需要一些特殊的对象：

struct toggled_ostream
{
    std::ostream& os;
};

inline toggled_ostream operator << (std::ostream& os, toggle_t)
{
    return { os };
}

当心，有人可能会放toggle错地方：cout << toggle << 123- 所以它应该适用于所有其他类型的普通流：

template <typename T>
std::ostream& operator << (toggled_ostream tos, const T& v)
{
    return tos.os << v;
}

所以 - 对于 char 类型（如char, const char*, std::string），请编写您的切换重载。我给你版本char- 为“更长”类型编写版本应该不是问题：

std::ostream& operator << (toggled_ostream tos, char v)
{
    char c = std::isupper(v) ? std::tolower(v)
                             : std::islower(v) ? std::toupper(v) : v;
    return tos.os << c;
}

工作演示。

Answer 3

你不能这样做。你可以做的是将字符串作为参数的操纵器，即

std::cout << toggle(str);
std::cin  >> toggle(str);

操纵器只是所谓的语法糖，即它可以比其他方式更方便地做事。例如，

std::cout << std::setw(5) << x <<;

会做同样的事情

std::cout.width(5);
std::cout << x;

但更方便，因为它允许与其他<<操作链接在一起。

现在，你想要的东西没有格式支持（交换大小写字符），因此也没有办法为此提供语法糖。

但是，如果操纵器可以将您的字符串作为参数，那么您当然可以实现您想要的，以操纵器实现的标准方式实现。例如，

struct toggle_output
{ std::string const&str; }

inline toggle_output toggle(std::string const&str)
{ return {str}; }

inline std::ostream& operator<<(std::ostream&out, toggle_output const&t)
{
  for(auto c:t.str)
    if     (std::islower(c)) out<<std::toupper(c);
    else if(std::isupper(c)) out<<std::tolower(c);
    else                     out<<c;
  return out;
}

struct toggle_input
{ std::string &str; }

inline toggle_input toggle(std::string&str)
{ return {str}; }

inline std::istream& operator>>(std::istream&in, toggle_input &t)
{
  in >> t.str;
  for(auto&c:t.str)
    if     (std::islower(c)) c=std::toupper(c);
    else if(std::isupper(c)) c=std::tolower(c);
  return in;
}

您可能还需要（避免混淆）

inline std::ostream& operator<<(std::ostream&out, toggle_input const&t)
{ return out<<toggle_output(t.str); }

Answer 4

正如其他答案所解释的，操纵器只是模仿现有的std::ios_base功能。

您的问题有一个简单的解决方案，但我不确定这是否可以称为操纵器：

struct toggle_in_helper
{
    std::string & res;
};

toggle_in_helper toggle (std::string & res)
{
    return {res};
}

std::istream & operator >> (std::istream & in, toggle_in_helper h)
{
    in >> h.res;
    for (auto & c : h.res)
        // toggle the case of 'c'
        ;
    return in;
}

也就是说，我们创建了一个toggle_in_helper重载的辅助类operator >>来完成这项工作。