C++知识点复习（三）

（1）new  delete重载：

      成员函数new的重载：

      void * 类名：：operator  new（size_t size）

      {}

      全局函数new的重载：

      void * operator  new（size_t size）

      {}

     成员函数的形式delete重载：

     void  类名：：operator  delete（void  *ptr）

     {}

     全局函数的形式delete重载：

     void operator  delete（void  *ptr）

     {}

（2）常用的流：

        iostream：输入输出流操作所需要的基本信息；

        fstream： 用户管理文件的IO操作；

        strstream： 字符串流IO；

        stdiostream：c、c++的IO机制；

        iomapip： 格式化IO的文件；

        iostream：

        cin：输入，cout：输出， cerr：错误流，clog：错误流；

        iostream重载<<运算符：

        ostream  operator<<(int)  :向输出流输入一个int数据；

        ostream  operator<<(float)  :向输出流输入一个float数据；

        ostream  operator<<(char)  :向输出流输入一个char数据；

        ostream  operator<<(char *)  :向输出流输入一个字符串数据；

（3）C++格式化的输出：

       cout<<"dec:"<<dec<<a<<endl;  十进制形式输出

       cout<<"hex:"<<hex<<a<<endl;  十六进制形式输出

       cout<<"oct:"<<setbase(8)<<a<<endl; 8进制输出整数a

       cout<<setfill('*')<<setw(10)<<pt<<endl;   //指定域宽,输出字符串,空白处以'*'填充 double 

       precision(n):设置实数的精度为n位；

       width(n)   setw(n)l 设置字段宽度为n位；

       setfill（c）：填充字符c；

（4）输出单个字符：

       cout.put('a');

（5）get函数：

       a.   不带参数的get函数：cin.get();

             从输入流中提取一个字符（包含空格）；返回值就是读入的字符；

             遇到输入流的文件结束符，则返回文件结束标志EOF。

       b.   带参数的get函数：cin.get(c);

             从输入流中读一个字符，赋值给c；

             成功true，失败false；

       c.   带三个参数的get函数：cin.get(字符数组，字符个数n，结束符);

             从输入流中读取n-1个字符到字符数组中，如果提前遇到结束符，提前结束；

      d.    getline,从输入流中读取一行字符，与get类似

             cin.getline(字符数组，字符个数，中止的标识符);

（6）文件操作：

        ifstream:支持从磁盘文件的输入；

        ofstream：支持向磁盘文件的输出；

        fstrem:支持对磁盘文件的输入输出；

        打开文件：

        a. 文件流的成员函数open

             ofstream outfile;

             outfile.open("f1.dat", ios::out);

             文件流对象.open(磁盘文件名， 输入输出方式);

        b. 关闭文件：

             outfile.close()

        c. 对ascii文件的操作

            ofstream outfile("f1111.dat",ios::out);  //定义文件流对象,打开磁盘文件"f1.dat"

            if(!outfile)                             //如果打开失败,outfile返回值
            {
                 cerr<<"open error!"<<endl;
                 exit(1);
            }

（7）对二进制文件的读写：

        read： istream &read(char *buff, int len);

        write：ostream &write (const char* buff, int len);
 
        a.write(p1, 10);  从p1所指的地方将10个字节写到文件中；

        b.read(p2, 30);   从文件中读30个字节放到p2所指的地方；

        看下面的一段代码操作：

#include <iostream>#include <fstream>using namespace std;struct student{   char name[20];   int num;   int age;   char sex;};int main( ){   student stud[3]={"Li",1001,18,'f',"Fun",1002,19,'m',"Wang",1004,17,'f'};   student stud2[3];      ofstream outfile("stud.dat",ios::binary);   if(!outfile)   {      cerr<<"open error!"<<endl;      abort( );//退出程序   }   for(int i=0;i<3;i++)      outfile.write((char*)&stud[i],sizeof(struct student));      outfile.close( );   ifstream infile("stud.dat",ios::binary);   if(!infile)   {cerr<<"infile open error!"<<endl;exit(1);   }   for(int i=0; i<3; i++)   {   infile.read((char *)&stud2[i], sizeof(struct student));   cout<<"xm:"<<stud2[i].name<<endl;   cout<<"xh:"<<stud2[i].num<<endl;   cout<<"ag:"<<stud2[i].age<<endl;   cout<<"sex:"<<stud2[i].sex<<endl;   }   infile.close();   return 0;}

        先将结构体中的数据写到文件中，再从文件中读出来；

（8）相关的文件指针流函数：

        gcount():返回最后一次输入多读入的字节数；

        tellg():返回输入文件指针的当前位置；

        seekg():将输入文件中的指针移动到指定的位置；

        seekg(位移量，参照位置)：以参考位置移动若干字节；

        tellp():返回输出文件指针当前的位置；

        seekp(文件中的位置)：输出文件中指针到指定的位置；

        seekp(位移量，参考位置):以参考位置为基础移动若干个字节；

        ios：：beg : 文件开头；

        ios：：cur :当前位置

        ios：：end  ：文件末尾；

        infile.seekg(50):  输入文件指针向下移动50字节；

        infile.seekg(-50, ios::cur):输入的文件指针从当前指针向上移动50

（9）对字符串流的操作：

       字符串流： istrstream ,ostrstream,strstream;

       输出时:    数据不是流向外存文件，而是流向内存中的一个存储空间。

       输入时:    从内存中的存储空间读取数据。在严格的意义上说，这不属于输入输出，称为读写比较合适

（10）容器：

         STL：标准的模板库

         六大组件：容器，迭代器，空间配置器，配接器，算法，仿函数；

         顺序容器：vector，deque，list

         关联容器：map，set

         容器适配器：queue，stack

         交互关系：

         容器通过空间配置器取得数据存储空间，空间配置器通过迭代器存取容器内容，

         仿函数可以协助空间配置器完成不同的策略变化，配接器可以修饰或套接仿函数、

（11）迭代器：

         每个容器都有迭代器，看作一个指针，用来存取容器内存储的数据。

         格式：

         <容器名><数据类型>iterator 迭代器变量名

         5种类型：

         输入input iterators：从容器中读取元素，一次读一个，方向向前；

         输出output iterators：向容器中写元素，一次写一个。

         向前：forword iterators：可以读写，还可以多次读写；

         双向的迭代器：birectional iterators：添加了向后的功能；

         随机存取迭代器：random access iterators：向前向后随意的移动。

（12）vector：

         连续的内存地址的数据结构，可以通过[]直接访问任何元素。

         vector用尽的时候，可以自动分配更大的连续内存区，将原来的元素复制到新的内存区，旧的释放。

         可以实现队列，堆栈，线性表等类似的数据结构。

         vector支持随机访问数据，称为vector元素的指针。
         头文件：
         #inlcude <vector>
         using namespace std;
         vector <int > a;    等效于int a[  ];

         a.  vector <int>  vec;

              vec.push_back(a);  //a插入到容器的尾部

              cout<<vec[0]<<endl;   //范围下标为0 的元素。

         b.  用迭代器访问元素：

              vect <int> ::iterator  it;

              for(it=vec.begin(); it !=vec.end(); it++)
    cout<<*it<<endl;

        c.   插入元素
              vec.insert(vec.begin()+i, a);在第i+1个元素前面插入a；

              vec.erase(vec.begin()+i, vec.end()+j);删除区间[i,j-1]

              iterator erase( iterator loc );

              iterator erase( iterator start, iterator end );

              erase函数要么删作指定位置loc的元素,要么删除区间[start, end)的所有元素.返回值是指向删除的最后一个元 

              素的下一位置的迭代器.

        d.   删除元素：

              vec.erase(vec.begin()+2);  删除第3个元素；

        e.   向量大小：vec.size();  返回vector的容纳元素的数目；

         f.   清空：vec.clear();

        g.   初始化
              vector   空的vector

              vector c1(c2); 复制一个和c2一样的vector c1；

              vector c(n); 创建一个vector，含有n个数据，数据缺省；

              vector c(n,elem)  ； 创建一个含有n个elem的vector；

              vector c(input iterator  start, input interator end);  构造一个初始值为[start, end)区间元素的vector；

       h.    析构函数： c.~vector();

              c.at(idx):越界，抛出异常；

（13）list：

         是由双向链表组成，链表的操作都适合：可前可后，不能随机访问。

         #include <list>

         list<int> link;      构造一个链表，存放整数；

         push_front():      在链表的头部添加一个元素；

         list <int>::iterator p =link.begin();  定义迭代器并初始化；

         link.end()返回末尾的迭代器；

         link.remove(16);  从链表里面删除16；

（14）deque：

         双向队列由双端队列组成，可以在队列的两端操作。

         支持随机访问和[]访问。

         关联容器：  

         set： 快速查找的，

         map：  映射查找，根据关键字查找，不允许重复值。

        容器适配器：

         stack：后进先出；

         queue：先进先出；

         prority_queue： 最高优先级第一个出列；

（15）关联容器和顺序容器的区别：

         关联容器是通过键key来存储和读取元素的；

         顺序容器是通过元素在容器中的位置顺序存储和访问元素。

         map：key和value组成，通过key找到value。

         #include  <map>

         #pragma warning (disable:4786)//屏蔽4786的警告提示，用stl大部分都要这样做