我想为ostream实现一个自定义操纵器,对插入到流中的下一个项目进行一些操作.例如,假设我有一个自定义操纵器引用：

std::ostringstream os;
std::string name("Joe");
os << "SELECT * FROM customers WHERE name = " << quote << name;

操纵者引用将引用名称以产生：

SELECT * FROM customers WHERE name = 'Joe'

我该如何完成呢？
谢谢.

将操纵器添加到C流特别困难,因为无法控制操纵器的使用方式.可以将新的语言环境灌输到流中,该流已安装了一个控制数字打印方式的方面 – 但不是如何输出字符串.然后问题仍然是如何将引用状态安全地存储到流中.

使用std命名空间中定义的运算符输出字符串.如果要更改打印方式,同时保持操纵器的外观,可以创建代理类：

namespace quoting {
struct quoting_proxy {
    explicit quoting_proxy(std::ostream & os):os(os){}

    template<typename Rhs>
    friend std::ostream & operator<<(quoting_proxy const& q,Rhs const& rhs) {
        return q.os << rhs;
    }

    friend std::ostream & operator<<(quoting_proxy const& q,std::string const& rhs) {
        return q.os << "'" << rhs << "'";
    }

    friend std::ostream & operator<<(quoting_proxy const& q,char const* rhs) {
        return q.os << "'" << rhs << "'";
    }
private:
    std::ostream & os;
};

struct quoting_creator { } quote;
quoting_proxy operator<<(std::ostream & os,quoting_creator) {
    return quoting_proxy(os);
}
}

int main() {
    std::cout << quoting::quote << "hello" << std::endl; 
}

哪个适合用于ostream.如果要进行概括,可以将其设为模板,也可以接受basic_stream而不是普通字符串.在某些情况下,它与标准操纵器有不同的行为.因为它通过返回代理对象来工作,所以它不适用于像

std::cout << quoting::quote; 
std::cout << "hello";

我想要的是简单地打开文件作为内存映射文件读取 – 以便将来以更快的速度访问它(例如：我们打开文件读取它结束,等待并反复读取它)同时我想要那个文件可由其他程序修改,当我修改它时,我希望我的ifstream也可以修改.如何使用boost iostreams(或者增强进程间)来做这样的事情？我们可以只是高大的 – 嘿,这个文件应该是所有应用程序的内存映射？

所以我尝试这样的代码：

#include <iostream> 
#include <boost/iostreams/device/mapped_file.hpp> 
#include <boost/iostreams/stream.hpp> 

using namespace boost::iostreams; 

int main(int argc,char **argv) 
{
    stream <mapped_file_sink> out; 
    try 
    { 

        mapped_file_params p("one.txt"); 
        p.new_file_size = 1024 * sizeof (char); 
        out.open(mapped_file_sink(p),std::ios_base::out | std::ios_base::binary); 
    } 
    catch (const std::exception &e) 
    { 
        std::cout << e.what() << std::endl; 
        return 2; 
    } 
    std::cin.get();
    return 0; 
}

所以它打开或创建文件,把它放入ram.但是我无法访问它(我无法编辑并保存但我可以打开)来自任何其他程序=(如何使文件可以从其他程序编辑？

我想你正在寻找文件访问速度,但为什么要重新发明轮子？使用内存映射分区并在其中创建文件.然后你只需要不时将它们同步到一个磁盘分区,这样你就不会在电源故障时丢失信息……你总是可以投资UPS ……

如果有一个文件foo.cpp,那么它通常有一个关联的头文件foo.h,其中包含foo.cpp中定义的函数的所有声明.这样,使用foo.cpp中的函数的所有其他文件都可以包含foo.h文件并使用它们.这是我对头文件的简单理解.

但是,我没有看到iostream头文件和iostream类之间的这种关系. iostream头文件只声明了一些外部变量,但它们似乎都没有直接与iostream类有任何关系. iostream类似乎也没有声明任何新函数.为什么我们有iostream类和iostream头文件？抱歉,如果我听起来很困惑,但这些东西真让我困惑.

标题和类之间的关系不一定是一对一的;这只是一个经验教训,经常教给新手程序员.事实上,C语言标准根本没有指定类,实现文件(翻译单元)和标题之间的任何直接关系,标准库通常偏离此规则.

std :: iostream是模板类std :: basic_iostream的typedef(具体来说,对于basic_iostream< char>).在我的平台上,< iostream>包括< istream>它定义了basic_iostream,以及< iosfwd>其中包含typedef.

我一直在编写iostreams的二进制版本.它本质上允许您编写二进制文件,但可以很好地控制文件的格式.用法示例：

my_file << binary::u32le << my_int << binary::u16le << my_string;

将my_int写为无符号的32位整数,将my_string写为长度前缀的字符串(前缀为u16le.)要读回文件,可以翻转箭头.效果很好.然而,我在设计上遇到了一个障碍,我仍然围着它.所以,是时候问问了. (我们做了一些假设,例如8位字节,2s补码整数和IEEE浮点数.)

引擎盖下的iostream使用streambufs.这真是一个非常棒的设计 – iostream将’int’的序列化编码到文本中,并让底层的streambuf处理其余部分.因此,你得到了cout,fstreams,stringstreams等.所有这些,包括iostream和streambufs,都是模板化的,通常是在char上,但有时也作为wchar.但是,我的数据是一个字节流,最好用’unsigned char’表示.

我的第一次尝试是基于unsigned char来模拟类. std :: basic_string模板足够好,但streambuf没有.我遇到了一个名为codecvt的类的几个问题,我永远无法遵循unsigned char主题.这提出了两个问题：

1)为什么streambuf对此类事情负责？似乎代码转换不属于streambuf的职责 – streambufs应该采取流,并缓冲数据到/从它缓冲数据.而已.像代码转换一样高级的东西感觉它应该属于iostreams.

由于我无法使用模板化的streambuf来处理unsigned char,所以我回到char,只是在char / unsigned char之间传递数据.出于显而易见的原因,我试图尽量减少演员阵容.大多数数据基本上都是在read()或write()函数中结束,然后调用底层的streambuf. (并在此过程中使用强制转换.)读取功能基本上是：

size_t read(unsigned char *buffer,size_t size)
{
    size_t ret;
    ret = stream()->sgetn(reinterpret_cast<char *>(buffer),size);
    // deal with ret for return size,eof,errors,etc.
    ...
}

好的解决方案,糟糕的解

前两个问题表明需要更多信息.首先,查看了boost :: serialization等项目,但它们存在于更高级别,因为它们定义了自己的二进制格式.这更适用于较低级别的读/写,其中希望定义格式,或者已经定义了格式,或者不需要或不需要批量元数据.

其次,有人问过binary :: u32le修饰符.它是一个类的实例化,它具有所需的字节顺序和宽度,此刻可能是未来的签名.该流保存该类的最后传递的实例的副本,并在序列化中使用该副本.这是一个解决方法,我试图重载<<运算符因此：

bostream &operator << (uint8_t n);
bostream &operator << (uint16_t n);
bostream &operator << (uint32_t n);
bostream &operator << (uint64_t n);

但当时,这似乎不起作用.我有一些模糊函数调用的问题.对于常数来说尤其如此,尽管你可以像一张海报建议的那样,将其演绎或仅仅声明为const< type>.我似乎记得有一些其他更大的问题.

我同意合法化.我需要做几乎正是你正在做的事情,然后看着重载<< />>,但得出的结论是iostream的设计并不适合它.首先,我不想将流类子类化以便能够定义我的重载.

我的解决方案(只需要在一台机器上临时序列化数据,因此不需要解决字节顺序)基于这种模式：

// deducible template argument read
template <class T>
void read_raw(std::istream& stream,T& value,typename boost::enable_if< boost::is_pod<T> >::type* dummy = 0)
{
    stream.read(reinterpret_cast<char*>(&value),sizeof(value));
}

// explicit template argument read
template <class T>
T read_raw(std::istream& stream)
{
    T value;
    read_raw(stream,value);
    return value;
}

template <class T>
void write_raw(std::ostream& stream,const T& value,typename boost::enable_if< boost::is_pod<T> >::type* dummy = 0)
{
    stream.write(reinterpret_cast<const char*>(&value),sizeof(value));
}

然后,我进一步为任何非POD类型(例如字符串)重载了read_raw / write_raw.请注意,只需要重载read_raw的第一个版本;如果您是use ADL correctly,则第二个(1-arg)版本可以调用稍后定义的2-arg重载以及其他名称空间.

写例子：

int32_t x;
int64_t y;
int8_t z;
write_raw(is,x);
write_raw(is,y);
write_raw<int16_t>(is,z); // explicitly write int8_t as int16_t

阅读示例：

int32_t x = read_raw<int32_t>(is); // explicit form
int64_t y;
read_raw(is,y); // implicit form
int8_t z = numeric_cast<int8_t>(read_raw<int16_t>(is));

它不像重载运算符那样性感,并且事情不容易在一条线上(我倾向于避免,因为调试断点是面向行的),但我认为它变得更简单,更明显,并且不多更冗长.