C++ 基础知识（三）

最新推荐文章于 2023-07-16 18:10:11 发布

生命如歌，代码如诗

最新推荐文章于 2023-07-16 18:10:11 发布

阅读量235

点赞数

分类专栏： C++ 语言文章标签： C 知识复习

本文链接：https://blog.csdn.net/ma950924/article/details/82984903

版权

C++ 语言专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1. new delete重载：
        成员函数new的重载：
        void*类名：：operator new（size_t size）
       {}
       全局函数new的重载：
       void *operator new（szie_t size）
       {}
       成员函数的形式delete重载：
       void 类名：：operator delete(void *ptr)
       {}
       全局函数delete的重载：
       void operator delete（void * ptr）
       {}

2. 常用的流：
       iostream:输入输出流操作所需要的基本信息；
       fstream:用户管理文件的IO操作；
       strstream:字符串流IO；
       stdiostream:C、C++D的IO机制；
       iomapip:格式化IO的文件；
       iostram：
       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<<end;十进制形式输出
        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)I 设置字段宽度为n位；
        setfill(c)：填充字符c；

4. 输出单个字符：
        cout.put(‘a’);

5. get函数：
       a.不带参数的get函数：cin.get();
           从输入流提取一个字符（包含空格）；返回值就是读入的字符；遇到输入流的文件结束符，则返回文件结束标志EOF；
       b.带参数的get函数：cin.get(c);
       成功true,失败false;
       c.带三个参数的get函数：cin.get(字符数组，字符数n,结束符)；从输入流中读取n-1个字符到字符数组中，如果提前遇到结束符，提前结束；
       d.getline,从输入流中读取一行字符，与get类似
           cin.getline(字符数组，字符个数，中止的标识符)；

6. 文件操作：
        ifstream:支持从磁盘文件的输入；
        ofstream:支持向磁盘文件的输出；
        fstream;支持对磁盘文件的输入输出；
        打开文件：
        a.文件流的成员函数open
            ofstream outfile;
            outfile.open("f1.dat",ios::out);
            文件流对象.open（磁盘文件名，输入输出方式）；
        b.关闭文件：
            outfile.close();
        c.对ascii文件的操作：
            ofstream outfile("f1.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(位移量，参照位置):以参照位置移动若干个字节
       teelp():返回输出文件指针的当前的位置；
       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 iterator：向容器中写元素，一次写一个。
        向前：forword iterators：可以读写，还可以多次读写；
        双向的迭代器：birectional iterators：添加了向后的功能；
        随机存取迭代器：random access iterators：向前向后随意的移动。

12. vector:
        连续的内存地址的数据结构，可以通过[]直接访问任何元素。
        vector用尽的时候，可以自动分配更大的连续内存区，将原来的元素复制到新的内存区，旧的释放。
        可以实现队列，堆栈，线性表等类似的数据结构。
        vector支持随机访问数据，称为vector元素的指针。
        头文件：
        #incldue <vector>
        using namespace std;
        vector <int> a; 等效于int a[];
        a.vector <int> vec
        vec.push_back(a); //a插入到容器的尾部；
        cout<<vec[0]<<endl; //输出范围下标为0的元素
       b.用迭代器访问元素
       vector <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(irerator loc);
       iterator erase(iterator start,iterator end);
       erase函数要么删除指定位置loc的元素，要么删除区间[start,end]的所有元素，返回值是指向删除的最后一个元素的下一个位置的迭代器。
       d.删除元素：
       vec.erase(vec.begin()+2);删除第三个元素；
       e.向量大小：vec.size();返回vectord 容器元素的数目；
       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>
        #prama warning(disable:4786)//屏蔽4786的警告提示，用stl大部分都要这样做

借鉴：https://blog.csdn.net/perfectguyipeng/article/details/73739770