精华内容
下载资源
问答
  • IStream与TStream之间的相互转换的代码
  • VB6 GDI+ 实现内存(Stream)压缩/解压缩 JPG 图像图像,保存为Isteam、Byte()所需要的封装函数类
  • C++ primer 第五版 中文版 练习 10.33 ...使用istream_iterator 读取输入文件。使用ostream_iterator将奇数写入第一个输出文件,每个值后都跟一个空格。将偶数写入第二个输出文件,每个值都独占一行。
  • IStream.zip IStream.tlb

    2015-03-24 12:30:51
    [VB]GDI+ IStream StdPicture Byte 互转 原网页已经删除了 所以在这里提供了
  • VC GDI+ 窗口截图内存BMP转JPG,压缩、JPG再转IStream流,IStream流再转 BYTE 上体见 http://blog.csdn.net/q610098308/article/details/78181933
  • c++文件输入类
  • NULL 博文链接:https://cherishlc.iteye.com/blog/2400974
  • 将IPLImage显示于MFC窗口,稍加修改可以显示二维数组图像
  • 主要介绍了C++中与输入相关的istream类成员函数简介,包括eof函数和peek函数以及putback函数还有ignore函数,需要的朋友可以参考下
  • c++中istream类的超详细说明

    千次阅读 2021-04-16 09:32:44
    根据前文,istream类是c++标准输入流的一个基类,本篇详细介绍istream类的主要成员函数用法。 1.istream的构造函数 从istream头文件中截取一部分关于构造函数的声明和定义,如下: public: explicit basic_istream...

    根据前文,istream类是c++标准输入流的一个基类,本篇详细介绍istream类的主要成员函数用法。

    1.istream的构造函数

    从istream头文件中截取一部分关于构造函数的声明和定义,如下:

    public:
    explicit
          basic_istream(__streambuf_type* __sb)
          : _M_gcount(streamsize(0))
          { this->init(__sb); }
    protected:
          basic_istream()
          : _M_gcount(streamsize(0))
          { this->init(0); }
    
    #if __cplusplus >= 201103L
          basic_istream(const basic_istream&) = delete;
    
          basic_istream(basic_istream&& __rhs)
          : __ios_type(), _M_gcount(__rhs._M_gcount)
          {
    	__ios_type::move(__rhs);
    	__rhs._M_gcount = 0;
          }
    
          // 27.7.3.3 Assign/swap
    
          basic_istream& operator=(const basic_istream&) = delete;
    
          basic_istream&
          operator=(basic_istream&& __rhs)
          {
    	swap(__rhs);
    	return *this;
          }
    

    可以看到istream类的默认构造函数是保护类型,而带参数的构造函数则是公有的,根据public和protected的功能,我们要定义一个istream对象,必须要在参数中传入streambuf类型的指针才可以,否则会报编译错误。

    一个可用的例子如下:

    #include <iostream>
    #include <fstream>
    
    using namespace std;
    
    int main()
    {
    	filebuf buf;
    	istream iii(&buf);
    	return 0;
    }
    

    这里应该有人会疑惑,怎么构造函数传的是filebuf类型的入参呢,原因是streambuf的构造函数也是保护类型,且只有一个无参构造函数,所以streambuf是不能直接定义一个对象的,需要使用它的继承者stringbuf或者filebuf,这里使用了filebuf。

    另外需要注意的是istream类的拷贝构造函数和赋值函数也都是保护类型的,所以istream是不允许拷贝或者赋值的,所以它也不能直接作为返回类型和参数传递,很多时候需要使用引用来进行传递。

    2.右移位>>操作符

    部分重载>>操作符函数原型如下:

    	//重载一系列>>操作符,读取各种数据类型的数据放入输入流中
          __istream_type&
          operator>>(__istream_type& (*__pf)(__istream_type&))
          { return __pf(*this); }
    
          __istream_type&
          operator>>(__ios_type& (*__pf)(__ios_type&))
          {
    	__pf(*this);
    	return *this;
          }
    
          __istream_type&
          operator>>(ios_base& (*__pf)(ios_base&))
          {
    	__pf(*this);
    	return *this;
          }
          
          __istream_type&
          operator>>(bool& __n)
          { return _M_extract(__n); }
    
          __istream_type&
          operator>>(short& __n);
    
          __istream_type&
          operator>>(unsigned short& __n)
          { return _M_extract(__n); }
    
          __istream_type&
          operator>>(int& __n);
    
          __istream_type&
          operator>>(unsigned int& __n)
          { return _M_extract(__n); }
    
          __istream_type&
          operator>>(long& __n)
          { return _M_extract(__n); }
    
          __istream_type&
          operator>>(unsigned long& __n)
          { return _M_extract(__n); }
    
    #ifdef _GLIBCXX_USE_LONG_LONG
          __istream_type&
          operator>>(long long& __n)
          { return _M_extract(__n); }
    
          __istream_type&
          operator>>(unsigned long long& __n)
          { return _M_extract(__n); }
    #endif
          __istream_type&
          operator>>(float& __f)
          { return _M_extract(__f); }
    
          __istream_type&
          operator>>(double& __f)
          { return _M_extract(__f); }
    
          __istream_type&
          operator>>(long double& __f)
          { return _M_extract(__f); }
    

    >>操作符可用于从缓冲区提取数据并存储在变量中,使用例子如下:

    #include <iostream>
    #include <fstream>
    
    using namespace std;
    
    int main()
    {
    	filebuf buf;
    	//aaa.txt是文本文件,内容是1234
    	if ( buf.open("aaa.txt", ios::in) == nullptr )
    	{
    		cout << "打开文件出错" << endl;
    		return -1;
    	}
    	istream is(&buf);
    	char c = 0x00;
    	int i = 0;
    	is >> c >> i;
    	cout << "c=" << c << endl << "i=" << i << endl;
    	return 0;
    }
    

    输出结果如下:

    c=1
    i=234
    

    到这里,其实看到is这个变量的用法很熟悉,就是我们常用的cin的用法,因为cin它就是istream类型的对象嘛,这里我们可以大概猜测一下cin是怎么实现的,比如:

    #include <iostream>
    #include <fstream>
    
    using namespace std;
    
    int main()
    {
    	filebuf buf;
    	if ( buf.open("/proc/self/fd/0", ios::in) == nullptr )
    	{
    		cout << "打开文件出错" << endl;
    		return -1;
    	}
    	istream is(&buf);
    	char c = 0x00;
    	int i = 0;
    	is >> c >> i;
    	cout << "c=" << c << endl << "i=" << i << endl;
    	return 0;
    }
    

    执行程序以后,会等待输入,然后在输出,如下:

    123
    c=1
    i=23
    

    从键盘输入123,回车以后,输出了我们想要的结果,这样就实现了跟cin一样的功能。

    /proc/self/fd/0是linux系统中标准输入文件,所以打开这个文件操作的话,反映在命令中中,就是在等待输入。

    3.get函数

    istream头文件中截取get函数声明,如下:

          //从输入流中读取一个字符(包括空白字符)并返回,若遇到结束符则返回eof()
          int_type
          get();
    
    	  //从输入流中读取一个字符并存储在引用参数__C中,如果遇到文件结束符,则__C为eof(),返回this指针
          __istream_type&
          get(char_type& __c);
    	  //从输入流中读取字符存储在__s指向的内存中,直到输入流被读取完或者读到了__n-1个字符才返回,其中如果在读取字符的过程中遇到了__delim所代表的字符,则提前返回,也就是说__delim相当于是一个终止字符
          __istream_type&
          get(char_type* __s, streamsize __n, char_type __delim);
    
          //从输入流中读取字符存储在__s指向的内存中,直到输入流被读取完或者读到了__n-1个字符才返回,其中如果遇到换行符,则提前返回,从实现看,可见就是上面那个函数的终止字符是换行符
          __istream_type&
          get(char_type* __s, streamsize __n)
          { return this->get(__s, __n, this->widen('\n')); }
    
          //从输入流中读取字符存储在streambuf对象__sb中,与终止字符__delim返回
          __istream_type&
          get(__streambuf_type& __sb, char_type __delim);
    
          //同理,是以上函数终止字符为换行符
          __istream_type&
          get(__streambuf_type& __sb)
          { return this->get(__sb, this->widen('\n')); }
    

    get函数部分使用例子如下:

    #include <iostream>
    #include <fstream>
    
    using namespace std;
    
    int main()
    {
    	filebuf buf;
    	if ( buf.open("/proc/self/fd/0", ios::in) == nullptr )
    	{
    		cout << "打开文件出错" << endl;
    		return -1;
    	}
    	istream is(&buf);
    	char g1 = 0x00;
    	g1 = is.get();
    	cout << "g1=" << g1 << endl;
    	is.ignore();//该函数是用于忽略换行符,避免下一次读取会读到换行符
    	char g2 = 0x00;
    	is.get(g2);
    	cout << "g2=" << g2 <<endl;
    	is.ignore();
    	char g3[12] = {0};
    	is.get(g3, sizeof(g3), 'n');
    	cout << "g3=" << g3 <<endl;
    	return 0;
    }
    
    4.getline函数用法

    getline函数原型如下:

          //读取一行的字符串放入__s指向的内存中,遇到终止字符__delim提前结束
          __istream_type&
          getline(char_type* __s, streamsize __n, char_type __delim);
    
          //读取一行的字符串放入__s指向的内存中,遇到换行符提前结束,相当于直接读取一行了
          __istream_type&
          getline(char_type* __s, streamsize __n)
          { return this->getline(__s, __n, this->widen('\n')); }
    

    用法如下:

    #include <iostream>
    #include <fstream>
    
    using namespace std;
    
    int main()
    {
    	filebuf buf;
    	if ( buf.open("/proc/self/fd/0", ios::in) == nullptr )
    	{
    		cout << "打开文件出错" << endl;
    		return -1;
    	}
    	istream is(&buf);
    	char g3[12] = {0};
    	is.getline(g3, sizeof(g3));
    	cout << "g3=" << g3 <<endl;
    	return 0;
    }
    

    这里就是使用了重载的第二个getline函数,默认遇换行符结束。
    此时我们输入:1234567,结果如下:

    1234567
    g3=1234567
    
    5.ignore函数和peek函数

    函数原型如下:

    //忽略输入流中的__n个字符,遇到字符__delim停止忽略并返回
          __istream_type&
          ignore(streamsize __n, int_type __delim);
    	  //忽略输入流中的__n个字符
          __istream_type&
          ignore(streamsize __n);
    
    	  //忽略输入流中字符
          __istream_type&
          ignore();
    	  //查看输入流中的下一个字符,但不会从输入流中取出来,字符指针位置也不会发生变化,就是看一眼
          int_type
          peek();
    

    使用方法如下:

    #include <iostream>
    #include <fstream>
    
    using namespace std;
    
    int main()
    {
    	filebuf buf;
    	if ( buf.open("/proc/self/fd/0", ios::in) == nullptr )
    	{
    		cout << "打开文件出错" << endl;
    		return -1;
    	}
    	istream is(&buf);
    	char g1 = 0x00;
    	char g3[12] = {0};
    	is >> g1;
    	cout << "g1=" << g1 << endl;
    	is.ignore(2);
    	is.ignore();
    	char g2 = 0x00;
    	g2 = is.peek();
    	cout << "g2=" << g2 << endl;
    	is.get(g3, sizeof(g3));
    	cout << "g3=" << g3 << endl;
    	return 0;
    }
    

    操作结果如下:

    1234567
    g1=1
    g2=5
    g3=567
    

    从这里我们可以知道ignore()不带参数的是忽略一个字符,带参数就是忽略n个字符,而peek只是取出了字符,但并没有移动字符指针。

    6.read函数和readsome函数
    //读取__n长度的字符串保存在__s中,直到读取完成__n个字符或者遇到文件结束符,eofbit及failbit都被置为1
          __istream_type&
          read(char_type* __s, streamsize __n);
    	  /*提取字符存储在__s中,能提取多少取决于streambuf缓冲区中剩余的字符数,查看剩余字符数可使用rdbuf()->in_avail(),rdbuf()就是缓冲区,in_avail()返回还有多少没有处理的字符,rdbuf()->in_avail()取值有如下几种情况:
    	  -1  说明遇到文件结束符或者没有可提取字符
    	  0   说明无可提取字符
    	  >0  可提取min(rdbuf()->in_avail(), __n)个字符
    	  readsome函数返回实际提取的字符数
    	  */
          streamsize
          readsome(char_type* __s, streamsize __n);
    

    使用例子如下:

    #include <iostream>
    #include <fstream>
    
    using namespace std;
    
    int main()
    {
    	filebuf buf;
    	if ( buf.open("/proc/self/fd/0", ios::in) == nullptr )
    	{
    		cout << "打开文件出错" << endl;
    		return -1;
    	}
    	istream is(&buf);
    	char szRead[12] = {0};
    	is.read(szRead, sizeof(szRead));
    	cout << "szRead=" << szRead << endl;
    	return 0;
    }
    

    如果键盘输入不够12个字符,read函数读取不会返回,知道读取12个字符为止。
    而如果read函数换成readsome函数,就会直接返回,并不会等待输入,也就是目前缓冲区有多少那么读多少,没有也不等待。

    7.putback函数、unget函数、sync函数

    函数原型如下:

    	//将前面从输入流中读取的字符__C返回到输入流,插入到当前指针位置,注意返回的字符一定要是之前读取过的,否则是不起作用的
          __istream_type&
          putback(char_type __c);
    
          //恢复上一个被读取的字符,重新放回到输入流中,恢复到它原本所在的位置
          __istream_type&
          unget();
    
          //刷新streambuf缓冲区,丢弃剩余没有读取的字符
          int
          sync();
    	  
    	  //返回上一次从流中提取的字节数
          streamsize
          gcount() const
          { return _M_gcount; }
    

    实例如下:

    #include <iostream>
    #include <fstream>
    
    using namespace std;
    
    int main()
    {
    	filebuf buf;
    	if ( buf.open("aaa.txt", ios::in) == nullptr )
    	{
    		cout << "打开文件出错" << endl;
    		return -1;
    	}
    	istream is(&buf);
    	char aa = 0x00;
    	char szRead[12] = {0};
    	int i = 0;
    	is >> aa;
    	cout << "aa=" << aa << endl;
    	is >> aa;
    	cout << "aa=" << aa << endl;
    	is.putback('1');
    	is >> aa;
    	cout << "aa=" << aa << endl;
    	is.unget();
    	is >> i;
    	cout << "i=" << i << endl;
    	return 0;
    }
    

    文件aaa.txt内容是1234,输出结果如下:

    aa=1
    aa=2
    aa=1
    i=134
    

    从结果可以看出putback可以放回之前提取的任意一个字符,而unget是直接放回上一个提取的字符。

    8.tellg和seekg函数
          //返回当前字符指针的位置
          pos_type
          tellg();
    
          //根据参数跳转当前字符指针位置,默认按照开始位置跳转
          __istream_type&
          seekg(pos_type);
    
    	  //根据参数跳转当前字符指针位置,ios_base::seekdir标示从什么位置开始跳转
          __istream_type&
          seekg(off_type, ios_base::seekdir);
    

    一个实际使用案例如下:

    #include <iostream>
    #include <fstream>
    
    using namespace std;
    
    int main()
    {
    	filebuf buf;
    	if ( buf.open("aaa.txt", ios::in) == nullptr )
    	{
    		cout << "打开文件出错" << endl;
    		return -1;
    	}
    	istream is(&buf);
    	char aa = 0x00;
    	char bb = 0x00;
    	aa = is.get();
    	bb = is.get();
    	cout << "tellg=" << is.tellg() << endl;
    	is.seekg(1, ios::beg);//从文件开始处跳转一个位置
    	cout << "tellg=" << is.tellg() << endl;
    
    	return 0;
    }
    

    结果如下:

    tellg=2
    tellg=1
    

    到这里,istream类的public成员函数就介绍完毕啦,若有不对之处,欢迎指正。

    在这里插入图片描述

    展开全文
  • Istream.tlb

    2014-07-20 17:34:01
    传说中的ISTREAM.TLB 这个可是找了好久才找到的呢
  • cannot bind ‘std::istream {aka std::basic_istream<char>}’ lvalue to ‘std::basic_istream<char>&&’ 有大佬能解释一下吗?我看了一些英文解答没太看懂。。 谢谢! ``` class CPoint{ private: ...
  • C++中istream的使用

    万次阅读 2018-11-08 21:58:32
    C++中istream的使用

    分享一下我老师大神的人工智能教程!零基础,通俗易懂!http://blog.csdn.net/jiangjunshow

    也欢迎大家转载本篇文章。分享知识,造福人民,实现我们中华民族伟大复兴!

                   

     在项目中会经常用到读取一些配置数据,这些数据根据实际需要有可能会调整,如果将这些数据直接嵌入进代码中会非常不便,需要经常调整代码。将这些数据写入配置文件中然后在读入,如果需要调整,只需修改配置文件,code不用作任何改动,这样会非常方便。最常用到的读取配置文件的方式是使用istream类。

     std::istream: input stream. Input stream objects can read and interpret input from sequences of characters. The standard object cin is an object of this type.

     标准中定义的std::cin就是istream类型。istream是std::basic_istream类模板的一个实例化。

     c++中定义的标准输入输出流是istream和ostream,他们是iostream类的父类,而cin是istream的对象,cout是ostream的对象。头文件fstream(对文件操作的流)包含了ifstream和ofstream,头文件sstream(对字符串操作的流)包含了istringstream和ostringstream,这些类都是继承自istream和ostream的。它们的关系如下图:


     有两种情况会使一个istream对象的bool转型为false:读到EOF(文件结束标志)或遇到一个无效的值(输入流进入fail状态)。istream对象的bool转型为false的情况下,此后的所有读入动作都是无操作。直到调用istream对象的成员函数clear()来清除该对象的内部状态。

     缺省情况下,输入操作符丢弃空白符、空格符、制表符、换行符以及回车。如果希望读入上述字符,或读入原始的输入数据,一种方法是使用istream的get()成员函数来读取一个字符,另一种方法是使用istream的getline()成员函数来读取多个字符。istream的read(char* addr, streamsize size)函数从输入流中提取size个连续的字节,并将其放在地址从addr开始的内存中。istream成员函数gcount()返回由最后的get()、getline()、read()调用实际提取的字符数。read()一般多用在读取二进制文件,读取块数据。

     输入流有三个函数来测试流状态:即bad(),fail()和eof()。ignore()用来抛掉指定个数的缓冲区中的字节。如果bad()为真,代表是遇到了系统级的故障。如果fail()为真,则表示输入了非法的字符。

     其它的istream成员函数:putback( char c ) 将字符放回iostream;unget()往回重置”下一个”istream项;peek()返回下一个字符或EOF,但不要提取出来。

     以下是测试代码:

    #include <iostream>#include <fstream>#include <string>#include "istream.hpp"void test_istream()//std::istringstream std::filebuf in; if (!in.open("E:/GitCode/Messy_Test/testdata/istream.data", std::ios::in)) {  std::cout << "fail to open file" << std::endl;  return; } std::istream iss(&in)std::string str; int count = 0while (!iss.eof()) {  if (iss.bad()) {   std::cout << "input stream corrupted" << std::endl;   break;  }  if (iss.fail()) {   std::cout << "bad data" << std::endl;   iss.clear(std::istream::failbit);   iss.ignore(256, '\n');   continue;  }  std::getline(iss, str);  if (str == "#filename:") {   iss >> str;   std::cout << "file name: " << str << std::endl;  }  if (str == "#content:") {   std::getline(iss, str);   std::cout << "file content: " << str << std::endl;  }  if (str == "#add operation:") {   int a, b;   iss >> a >> b;   std::cout << "a + b = " << (a + b) << std::endl;  }  if (str == "#char array:") {   char a, b, c, d, e, f;   iss >> a >> b >> c >> d >> e >> f;   std::cout << a << "  " << b << "  " << c << "  " << d << "  " << e << "  " << f << std::endl;  }  if (str == "#int array:") {   int arr[2][3];   for (int i = 0; i < 2; i++) {    for (int j = 0; j < 3; j++) {     iss >> arr[i][j];    }   }   for (int i = 0; i < 2; i++) {    for (int j = 0; j < 3; j++) {     std::cout << arr[i][j] << "    ";    }    std::cout << std::endl;   }  }  if (str == "#mean value:") {   float mean_value;   iss >> mean_value;   std::cout << "mean_value = " << mean_value << std::endl;  } } in.close();}
     执行结果如下图:
     主要参考文献:
     1. http://www.cplusplus.com/reference/istream/istream/
     2. http://www.zaojiahua.com/inputoutput-stream.html 

               

    给我老师的人工智能教程打call!http://blog.csdn.net/jiangjunshow

    这里写图片描述
    展开全文
  • IStream读取保存图像

    2010-12-10 20:03:55
    IStream读取图像,用Istorge保存
  • C++重载istream和ostream

    千次阅读 2020-10-19 20:16:05
    } 这里重载的 “+”号,是因为我们可以直接去修改对象的值 然而,对于 << >>来说,其左侧必须是istream 或者 ostream的对象,我们没办法去直接改变istream对象的值(不然就得去的源代码中修改),所以也就没办法把...

    对于一般的运算符重载,可以重载为类的成员函数,这是因为操作符的第一个元素一定是本类的对象(this)

    例如

    #include<iostream>
    using namespace std;
    
    class book {
    public:
        book (int n):bookNo(n) {}
        int getBookNo () {
            return bookNo;
        }
        book operator+ (book b) {
            book result(0);
            result.bookNo = bookNo + b.bookNo;
            return result;        
        }
    private:
        int bookNo;
    };
    
    int main () {
        book a(10), b(20);
        auto res = a + b;
        cout << res.getBookNo();
    }

    这里重载的 “+”号,是因为我们可以直接去修改对象的值

    然而,对于 << >>来说,其左侧必须是istream 或者 ostream的对象,我们没办法去直接改变istream对象的值(不然就得去<iostream>的源代码中修改),所以也就没办法把它写为当前类的成员函数。

    解决方法1:

    申明为当前类的友元函数,这样就可以直接访问类的私有对象(但是会破坏封装性)

    #include<iostream>
    using namespace std;
    
    class book {
    public:
        int getBookNo () {
            return bookNo;
        }
        friend istream& operator>> (istream& in, book& b);
        friend ostream& operator<< (ostream& out, book b);
    private:
        int bookNo;
    };
    
    istream& operator>> (istream& in, book& b) {
        in >> b.bookNo;
        return in;
    }
    ostream& operator<< (ostream& out, book b) {
        out << b.bookNo;
        return out;
    }
    
    int main () {
        book b;
        cout << "input book number: ";
        cin >> b;
        // cout << "book number is " << b.getBookNo() << endl;
        cout << b;
    }
    
    

    可以看到声明为book类友元的全局函数operator<< 和 operator >>直接访问了book类的私有变量成员bookNo

    解决方法2:

    使用一些成员函数来暴露对类成员的访问,然后使用类外的普通函数重载来进行类成员的输入输出。

    #include<iostream>
    using namespace std;
    
    class book {
    public:
        int getBookNo () {
            return bookNo;
        }
        void setBookNo (int n) {
            bookNo = n;
        }
    private:
        int bookNo;
    };
    
    istream& operator>> (istream& in, book& b) {
        int tmp;
        in >> tmp;
        b.setBookNo(tmp);
        return in;
    }
    ostream& operator<< (ostream& out, book b) {
        out << b.getBookNo();
        return out;
    }
    
    int main () {
        book b;
        cout << "input book num: ";
        cin >> b;
        cout << "book num is " << b;
    }
    
    

    至于为什么这里返回的是引用呢?

    这里还没彻底弄明白,如果返回的不是引用,会报如下错误:

    也就是当返回值不是引用时,就会调用拷贝构造函数,但是看上图可知道 istream和ostream的拷贝构造都被显示的删掉了!!

    那为什么要显示的删掉拷贝构造呢?

    是因为要保证输入,输出流对象是同一个对象

    比如,cin >> a >> b;

    如果返回不是引用,那么cin >> a产生一个istream的对象(开辟一段新空间),又作为 >> b左侧的istream的对象,这两个对象不能保证是同一个对象。可能发生如下情况:

    而返回时引用的时候,可以保证,cin >> a >> b >> c都在同一个流对象中

     

    展开全文
  • IStream

    千次阅读 2015-12-03 10:25:18
    MSDN:https://msdn.microsoft.com/en-us/library/windows/desktop/aa380034(v=vs.... 使用参考文章: Embracing IStream as just a stream of bytes 用CImage加载内存里的Image: 来源:http://www.cppblog.c

    MSDN:https://msdn.microsoft.com/en-us/library/windows/desktop/aa380034(v=vs.85).aspx


    使用参考文章:

    Embracing IStream as just a stream of bytes


    用CImage加载内存里的Image:

    来源:http://www.cppblog.com/mythma/archive/2013/12/13/8384.html

    问题:已知一块内存,知道里面是一张图片的数据,如何显示出来?

    一种解决方法:
    CImage(MFC or ATL)提供了一个加载内存中Image的成员函数HRESULT CImage::Load(IStream* pStream)。如何把指定的内存转换为IStream接口就成了需要解决的问题。最后发现获取一个ISteam还真是曲折:):


     

     void  LoadMemImage( void *  pMemData,  long  len)
     {
      HGLOBAL hGlobal  =  GlobalAlloc(GMEM_MOVEABLE, len);
       void *  pData  =  GlobalLock(hGlobal);
      memcpy(pData, pMemData, len);
      GlobalUnlock(hGlobal);

      IStream *  pStream  =  NULL;
       if  (CreateStreamOnHGlobal(hGlobal, TRUE,  & pStream)  ==  S_OK)
       {
       CImage image;
        if (SUCCEEDED(image.Load(pStream)))
        {
         //   .. 
     

       } 

       pStream -> Release();     
      } 

      GlobalFree(hGlobal); //这里似乎不需要释放。红色的TRUE表示Release会自动释放!



    展开全文
  • std :: istream typedef basic_istream<char> istream; Input stream 输入流对象可以读取和解释字符序列的输入 这是一个basic_istream实例具有以下模板参数: 模板参数 定义 评论 charT ...
  • class basic_istream; 输入流: 输入流对象可以读取和解释字符序列中的输入。提供了特定的成员来执行这些输入操作(参见下面的函数)。 模板实例化 它对常用字符类型定义了二个具体类: 类型 定义 ...
  • 005:山寨版istream_iterator 描述 模仿C++标准模板库istream_iterator用法,实现CMyistream_iterator使得程序按要求输出 #include <iostream> #include <string> using namespace std; template <...
  • 代码 // this.cpp #include<iostream> #include<string> #include<fstream>...void print(istream &strm, ifstream &fstrm) { string c; while(getline(strm,c)) {...
  • Istream中的函数

    2019-10-06 00:16:46
    Istream中的函数 Istream中的函数_刻卜浪兴_新浪博客Istream中的函数(2011-12-30 16:06:38)转载▼标签:杂谈 Istream中一些非常用但很有用的函数。我们常使用>>, getline(),但是其实istre...
  • 下述代码报错,原因是因为istream后漏了一个 & //从输入流中将家庭作业的成绩读入到一个vector<double>中 istream read_hw(istream& in, vector<double>& hw) { if (in) { //清除vector...
  • 所以对于一般要自定义流式操作需要了解istream/ostream, streambuf这两个类的用途。 这里只用istream也就是输入流举例: istream定义了对设备或者buffer的操作方法,包含的方法有read,readsome, >>这些读取...
  • 文章目录I/Ocin>>get()与cin.get()cin.getline()getline()gets() I/O ...cin是一个istream类的对象,它从标准输入设备(键盘)获取数据,程序中的变量通过流提取运算符>>从流中提取数...
  • 今天在看《STL源码剖析》的时候,看到了配接器中的ostream iterator,其中包含istream_iterator以及ostream_iterator以及更多,感觉这两个都十分重要,所以在这里介绍一下 istream_iterator 源码: template &...
  • 其中看到了istream_iterator的实现源码,源码如下: template <class T, class Distance = ptrdiff_t> class istream_iterator { friend bool operator== __STL_NULL_TMPL_ARGS (const istream_iterator&...
  • istream_iterator简单用法

    2020-09-27 14:58:15
    istream迭代器 利用输入流迭代器istream_iterator进行文件操作: std::ifstream i_file("data.txt"); //打开文件 istream_iterator<string> getStr(i_file); //从i_file读取字符串 istream_iterator<...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,556
精华内容 18,222
关键字:

istream