C++知识的总结回顾

#include
#include<stdio.h>
#include //可以使用函数strlen()查看字符串长度
using namespace std;
int main()
{
const int Months = 12; //常量
cout << “Hello world!” << endl;
//or cout << “Hello world!\n”;
printf(“Hello world!”); //printf 和 scanf需要引用头文件stdio.h
return 0;
}
/**
数据类型：
char, unsigned char, signed char, int, unsigned int, signed int, short int, unsigned short int,
long int, signed long int, unsigned long int, float, double, long double, wchar_t宽字符2或4个字节

• */

//预处理语句 define ZERO 0
//cout << hex; hex十六进制，oct八进制， dec 十进制

//cin.get() cout.put()

//转义字符 \u加4位十六进制数 \U加8位十六进制数

//const限定符，后面的变量变为常量

//数组声明 short months[12]; 下标从0开始
//sizeof months[0] 查看有多少字节

//字符串 char dog[3] = {‘I’, ‘L’, ‘U’};不是字符串， char dog[4] = {‘I’, ‘L’, ‘U’, ‘\0’};才是字符串
//char fish[] = “Bubbles” 字符串初始化，会在结尾处自动添加\0空字符。

//getline()读取到换行符，丢弃换行符，cin.get()不会丢弃换行符，需要两个get函数，可以读取换行符
//cin.getline(name, 20) 变量名和长度,会自动添加\0
//cin.get(name,Size);读取到空行后将设置失效位，意味着接下来的输入将会被阻断，但是可以用cin.clear()来恢复输入

//string类类似于名称空间std一样需要using编译指令，或者std::string来引用它。
//string str1 = “panther”;

//字符串拼接str1+str2
//strcat():将字符串附加到字符数组末尾， strcpy(char1, char2);将char2复制给char1
//str1.size() strlen(char1);

//结构体
/*struct inflatable

• {
• char name[20];
• float volume;
• };
  */
  //结构体初始化 inflatable hat;
  //inflatable hat = {“hello”, 12};

//可以将结构体当作参数传递给函数，或者函数返回一个结构体，也可以使用=符号将结构赋值给另一个同类型的结构体
//结构体数组inflatable gifts[100];
//结构体数组初始化gifts = {{“Bambi”, 0.5}, {“Godzilla”, 2000}};
//结构体中的位字段
/*struct torgle_register

• {
• unsigned int SN:4; 4 bit for SN value;
• unsigned int:4;
• bool goodln:1;
• boo gooTorgle:1;
• };
  */

//共同体：能够存储不同的数据类型，但只能同时存储其中的一种类型。
//union one4all
//{
// int int_val;
// long long_val;
// double double_val;
//};
// one4all pail;
// pail.int_val = 15;
// 共同体必须有足够的空间来存储最大的成员，并且可以嵌入结构体中成为结构体中的一个成员变量。

//枚举
//enum spectrum
//{
// read, orange, yellow, green, blue
//};
//分别对应0-4
//spectrum band; band = blue;只能将枚举的成员变量赋值给该变量，如果将其他值赋值会引发错误
// enum bits{one=1, two=2, ont, numero=3}

// 指针是一个变量，其存储的是值的地址，而不是值本身，&取地址符， *指针指向的值
//int *pt, pt=(int *)0xB8000000; //指针声明以及赋值
//使用new运算符
//int *pn = new int;
//new会从堆或者自由存储空间的内存中分配内存，nights会从栈的内存区域中分配内存
//delete释放内存，int *ps = net int; delete ps;
//delete会释放ps指向的内存，但不会删除指针ps本身，可以将ps重新指向另一个新分配的内存块。
//使用new来创建动态数组，int ps = new int[10]; delete [] ps;
//使用new建立数组，只需使用ps[0],ps[1]就可以新建。
//(ps+1) = ps[1]
//sizeof是指针长度。
//C++将数组名解释为指针
//&tell[0]是一个2字节内存块的地址，&tell是一个20字节内存块的地址，因此tell+1将地址值加2,而&tell+1将地址加20.

//int *pw = “wages”;
//new可以创建结构体，inflatable *ps = new inflatable;
//结构体指针访问结构体内部成员(*ps).price or ps->price;

//内存泄漏：如果new新建的变量没有使用delete取消，而包含指针的内存由于作用域规则和对象生命周期的原因而被释放，此时在自由存储空间上动态分配的变量或结构也将继续存在，同时也将无法访问自由存储空间中的结构，因为指向这些内存的指针无效，这将导致内存泄漏，被泄漏的内存将在程序的整个生命周期内都不可使用，最终可能导致内存耗尽错误，导致程序崩溃。

//结构体指针赋值：antarctica_years *ps = &s02 or = {&s01, &s02, &s03};

//数组的替代品vector和array
//vector和string类类似，也是一种动态数组可以在运行阶段或者末尾附加新数据，vector也是用new和delete来管理内存的，但是工作是自动完成。
//vector vi(n); 使用vector需要使用using name std编译或者使用std::vector;
//array是固定长度数组，需要包含#include array <int,5> arr;

//for(int i =0; i < 5; i++)
//{
//}

//++运算符可以用于指针， ++pt or pt++;
//,运算符可以确保先计算第一个式子再计算第二个式子

//string类 string word; string对象最后一位并不是空字符‘\0’，是封装好的，所以无法知道

//while()
//{
//}
//
//do
//{
//}
//while()

//C++中ctime库中有函数clock()可以返回当前时间，一个符号常量CLOCKS——PER——SEC,该常量等于每秒钟包含的系统时间单位数，计算时间差的方法,使用clock_t来声明时间变量。
//#include
//clock_t delay = sec*CLOCKS_PER_SEC;
//clock_t start = clock();
//while(clock()-start < delay)
//{
//}

//定义别名 #define Byte char; or typedef char byte;

//基于范围的for循环：对于数组（或容器类，如vector和array）
//double prices[5] = {4.99, 10.99, 6.99, 7.99}
//for(double x : prices)
//{
// cout << x << endl; //可以打印出来数组中的各个值，但是无法修改值
//}
//
//for(double &x:prices)
//{
// x = x*10; //可以改变数组中的值，此时是变量的引用，x和数组中的变量指向相同的值和内存单元
//}

//键盘读取：
//while(ch!=‘#’)
//{
// char ch;
// cin.get(ch)
//}
//文件读取：
//cin.eof()判断eofbit是否为1,为1表示读取结束，cin.fail()判断failbit是否为1,为1表示读取失败
//cin.clear()可以清楚标志位使其变为0,循环输入时，如果输入错误则需要清除标志位才能继续输入

//初始化二维数组：int maxtemps[3][2]={ {96,19}, {12,10}, {1,2} }
//for语句嵌套
//for()
//{
// for()
// {
// }
//}

//分支语句和逻辑运算符
//if()
//{
// statement
//}
//else if()
//{
// statement
//}
//else
//{
//
//}

//cctype字符函数库，用到了再详细看

//三元运算符？ 5>3?10:12 如果5>3则为10,否则为12

//switch(integer-expression)
//{
// case label1:statement; break;
// case label2:statement; break;
// default:statement;
//}

//break用于switch语句中跳出switch或循环后面的语句，continue用于循环中，让程序跳过循环体中余下的代码，并开始新一轮循环

/*简单文件输入/输出

• 输出信息到文件中，包含头文件fstream #include,
• 需要声明对象ofstream，用法和cout类似。
• ofstream outfile;
• outfile.open(“fish.txt”) //打开文件
• outfile << “hello world!” << endl;
• 读取文本需要包含头文件ifstream #include
• 需要生命对象ifstream对象
• ifstream infile;
• infile.open(“fish.txt”);
• string wt;
• infile >> wt;
• char line[80];
• infile.getline(line, 80);
  */
  //exit(EXIT_FAILURE) //终止程序，需要包含头文件cstdlib
  //也可以使用good()函数判断文档是否正常，infile.good(),如果文件损坏可以使用bad()方法，此时bad()方法会返回true.

/*C++编程模块

• C++函数，在执行函数simple()时，主函数main()将会暂停
• 函数：
• void simple(parameterList) //用，隔开参数
• {
• statement;
• return 0;
• }
• C++函数中不能返回数组，但是可以将数组作为结构体或者对象组成部分来返回。

*int sum_arr(int arr[], int n);
*int sum_arr(int *arr, int n);
*int sum_arr(cookies, number); cookies是数组
*/
/*指针和const

• 无法修改指针指向的值的方法：
• 方法一：将指针指向一个常量
• 方法二：const int *pt = &age;age并不一定是常量，只是无法通过指针pt来修改该值
• int *const pt = &age; //该格式表示pt只能指向age，无法修改pt指向的内存位置
• 还可以声明：const double *const stick = &trouble;
  */

/*函数和二维数组

• int sum(int ar[][4], int size); //声明函数
• int sum(int(*ar)[4],int size); //引用函数
  */

/*递归

• void recurs(argumentlist)
• {
• statements;
• if(test)

•  recurs(arguments);
  

• statements2;
• }
• test为false时，调用链将断开
  */

/*函数指针
*double pam(int); //函数
*double (*pt)(int); //pt表示为函数指针
*double *pt(int); 表示返回指针的函数
*/

/*内联函数

• inline double square(double x){ return x*x; } //声明和函数原型一起写，放在调用函数之前.
• b = square(5); //使用
• 如果函数过大或者函数调用自己（递归函数），则不能将其作为内联函数。
• #define SQUARE(X) X*X X是一个“参数标记”，
• a = SQUARE(5.0);使用 不能输入4.0+7.0,这样将会变为4.0+7.0 × 4.0+7.0
  */

/*引用变量

• int &rodents = rats; 这里不是表示取地址符，而是表示引用，将rodents作为rats变量的别名，它们指向相同的值和内存单元
• 引用必须在声明时就要对其进行初始化
• int &rodent=rat; 而不能int &rodent; rodent = rat;
• 函数引用传递void swapr(int &a, int &b);
• 按引用传递和普通的按值传递在使用函数时很相似，只能通过函数原型才可以分辨出。
• 按地址传递：swapr(int *p, int *q); swapr(&a, &b);
  */

/右值引用：double &&jref= 2.0j + 18.5; */

/结构体引用：struct free_throws{ std::string name; int made}/

/*函数默认参数： char *left(const char str, int n=1);/

/函数重载：函数名可以相同，但是函数的特征标不同即可实现函数重载，函数特征标不同可以是函数参数数量不同以及参数类型不同/

/*函数模板：

• 定义一个模板:template
• void Swap(AnyType &a, AnyType &b)
• {
• }
  *函数模板也可以重载：
  *void swap(job &a, job &b);
  *template
  *void swap(T &a, T &b);
  如果使用函数swap,传入参数类型为job的话，则使用第一个函数，如果不为job类型，则使用函数模板/

/内存模型和名称空间/

/*单独编译

• 在引用编写的头文件时要使用“coordin.h”，而不是<coordin.h>
• 头文件被包含在<>括号中时，C++编译器将在存储标准头文件的主机系统的文件系统中查找bugout包含双引号中，则C++编译器将在当前工作目录或者源代码目录中，如果没有找到头文件，则将在标准位置查找。
• 头文件格式coordin.h
• #ifndef COORDIN_H_
• #define COORDIN_H_
• #endif
• 如果没有使用预处理编译指令#define定义名称COORDIN_H_时，才处理#define到#endif之间的语句
  */

/*存储持续性、作用域和链接性

• 自动存储持续性：在函数定义中声明的变量（包括函数参数）的存储持续性为自动的。它们在程序开始执行其所属的函数或者代码块时被创建，在执行完函数或代码块时，他们使用的内存被释放。
• 静态存储持续性：在函数定义外定义的变量和使用关键字static定义的变量的存储持续性为静态，它们在程序整个运行过程中都存在。
• 线程存储持续性：CPU同时处理多个执行任务，使用关键字thread_local声明的变量，其声明周期与所属的线程一样长。
• 动态存储持续性：用new运算符分配的内存将一直存在，直到使用delete运算符将其释放或程序结束为止。
  */

/*作用域和链接

• 作用域描述了名称在文件的多大范围内可见。
• 公有方法和私有方法public和private
• 寄存器变量：关键字register,使用CPU寄存器来存储自动变量。
• 自动变量：auto，指出当前变量为局部自动变量
• int global = 1000; 具有外部链接性，可以在其他文件中使用该变量，需要添加关键字extern。
• static int one_file = 50; 只有内部链接性，文件外无法使用
• int main()
• void funct1(int n)
• {
• static int cout = 0; 无链接性，只能在函数中使用
• }
• 自动变量将隐藏同名的全局变量
• 作用域解析运算符::，该运算符放在变量前面，表示使用变量的全局版本。
• mutable可以用来指出，即使结构或者类变量为const,某成员也可以被修改。
  */

/*名称空间
*创建名称空间：
*namespace Jack
*{

• double pail;
• void fetch();
• int pal;
• struct Well{…};
  *}
  *访问名称空间
• 1.Jack::pail;
• 2.using jack::pail; pail = 0;
• 3.using namespace Jack; pail = 0;
• 注意：如果使用两个名称空间并且有相同名称的变量，则会报错。
• 名称空间可以嵌套
  */

/*对象和类

• 类包含两部分：类声明和类方法定义
• 类声明以数据成员的方式描述数据部分，类方法定义：描述如何实现类成员函数。
• 通用模板：
• #ifndef STOCK_H_
• #define STOCK_H_
• class Stock
• {
• private:

•  std::string company;
  

•  ...
  

• public:

•  void acquire(const std::string & co, long n, double pr);
  

•  void buy(long num, double price);
  

•  ...
  

• }
• #endif
• Stock sally;
• 公有成员函数是程序和对象的私有成员之间的桥梁，提供了对象和程序之间的结构。防止程序直接访问数据，被称为数据隐藏。
  */

/*类的构造函数和析构函数

• Stock::Stock(const string &co, long n, double pr)
• {
• }
• 构造函数要处于类空间中，构造函数的函数名要与类名相同。
• 程序在声明对象时，将自动调用构造函数。
• 使用构造函数
• Stock food = Stock(“world cabbage”, 250, 1.25);
• 隐式调用：Stock garment(“Furry Mason”, 50, 2.5);
• 默认构造函数
• 析构函数用于完成清理工作，如果使用new来新建变量，则需要在析构函数中使用delete
• Stock::~Stock();
• 代码构成，类中public和private变量和函数的声明.h头文件
• 类的方法（源文件）放在一个.cpp文件中
• 可以将一个对象赋值给另一个对象：stock1 = stock2;
• 类对象的列表初始化：
• Stock food = Stock(“world cabbage”, 250, 1.25);
• Stock garment(“Furry Mason”, 50, 2.5);
• 将对象声明为常量：const Stock land;
• 此时调用对象方法land.show();会报错，因为系统无法判断show()会不会改变对象。
• 解决方法：将函数声明为常量函数，在函数后添加const关键字
• 函数声明：void show() const; 函数原型：void Stock::show() const;
• 这样的函数成为const成员函数，只要类方法不修改调用对象，就应将其声明为const
  */

/* this指针

• 有时类成员函数涉及到两个同样的对象，这种情况下需要使用C++中的this指针
• const Stock &topval(const Stock &s) const;
• const Stock &Stock::topval(const Stock&s) const
• {
• if(s.total_val > total_val)

•  return s;
  

• else

•  return *this;
  

• }
• this指针指向用来调用成员函数的对象this指针设置为调用它的对象的地址，在topval()函数中total_val是this->total_val的简写
• 每个成员函数（包括构造函数和析构函数）都有一个this指针。如果方法需要引用整个调用对象，则可以使用表达式*this。在函数的括号后买你使用const限定符将this限定为const,这样就不能使用this来修改对象的值。
  */

/*对象数组

• Stock mystuff[4];
• 调用列表初始化：
• Stock stocks[4] = {Stock{“A”,12}, Stock(“B”,10),…};
• const Stock *top = &stocks[0];
• top = &top->toppval(stocks[st]);
  */

/*枚举类

• enum class egg {small, medium, large, jumbo}
• egg king = egg::large;
  */

/*运算符重载

• Typename operator () //重载运算符
• 运算符重载实例：
• class Time
• {
• public:

•  Time Sum(const Time &t) const;
  

• }
• Time Time::operator +(const Time &t) const
• {
• }
• total = coding.operator+(fixing);或者 total = coding + fixing;
• 如果出现多参数：t4 = t1+t2+t3;编译器在运行时会自动转换为t4=t1.operator+(t2+t3)
• t4 = t1.operator+(t2.operator+(t3));
• 可重载的运算符存在限制具体可以百度
• 重载的运算符不必是成员函数，但必须至少有一个操作数是用户定义的类型。
  */

/*友元函数

• A = B2.75; 可以使用重载运算符，A = B.operator2.75
• 但是如果写作A = 2.75*B;此时就不能像上面一样处理，此时就需要友元函数。
• 友元函数虽然不是成员函数，但是能够访问类的私有数据，和成员函数访问权限一样
• 友元函数的定义
• friend Time operator*(double m, const Time &t);
• 在编写函数时因为其不是成员函数，因此不需要使用Time::，同时，在使用时也不需要家friend.
• 例如：重写<<运算符
• ostream & operator << (ostream &os, const Time &t)
• {
• os << t.hours << “hours,” << t.minutes << " minutes";
• return os;
• }
  */

/*类的自动转换和强制类型转换

• Stonewt myCat;
• myCat = 19.6; //隐式转换 自动转换
• 显示转换：Stonewt myCat; myCat = Stonewt(19.6) 强制转换
• 转换函数：转换函数必须是类方法，转换函数不能指定返回类型，转换函数不能有参数
• 转换函数：operator typename(); 例如：operator double()
• typename指出了要转换成的类型，因此不需要指定返回类型。转换函数的类方法意味着：它需要通过类对象来调用，从而告知函数要转换的值
• 函数原型：
• Stonewt::operator double() const
• {
• return pounds;
• }
• 关键字explicit关键字，被声明的函数需要显式地调用时，函数才会执行
• explicit Stonewt::operator int() const;
• Stonewt poppons(9, 2.8);
• double p_wt = poppins; //用于将对象转换为其他类型。
  */

/*类和动态内存分配

• 涉及到new, delete, 构造函数和析构函数
• 在构造函数中使用new新建变量，在析构函数中使用delete来清楚
• 例如：
• class StringBad
• {
• private:

•  char *str;
  

• public:

•  StringBad(const char*s); 构造函数
  

•  StringBad(); 默认构造函数
  

•  ～StringBad();析构函数 
  

• }
• StringBad::StringBad(const char*s) //构造函数
• {
• len = std::strlen(s);
• str = new char[len+1];
• }
• StringBad::~StringBad() 析构函数
• {
• delete [] str;
• }
• int StringBad::num_strings = 0; //这条语句将静态成员num_strings的值初始化为0;注意不能在类声明中初始化静态成员变量
  */

/*类的特殊成员函数

• 默认构造函数
• 默认析构函数
• 复制构造函数
• 赋值运算符
• 地址运算符
• 复制构造函数用于将对象复制到新创建的对象中
• class_name(const Class_name&) 它接受一个指向类对象的常量引用作为参数，复制构造函数也是构造函数的一种,默认复制构造函数会逐个复制非静态成员（成员复制也称为浅复制），复制的是成员的值
• 赋值运算符：运算符重载 Class_name &Class_name::operator=(const Class_name &);
• StringBad knot;
• StringBad headline(“Celery Stalks at Midnight”);
• knot = headline; 此时用到赋值运算符
  */

/空指针关键字nullptr; str = nullptr;/

/*比较成员函数

• bool operator<(const String &st1, const String&st2)
• {
• if(std::strcmp(st1.str,st2.str)<0)

•  return true;
  

• else

•  return false;
  

• }
  */

/*队列模拟：链表

• struct Node
• {
• Item item; //类的类型为Item
• struct Node *next; //指向下一个结构体的指针，用来构成链表
• }
• 链表的最后一个是NULL或0;可以使用nullptr关键字
  */

/*类继承

• 从一个类别派生出另一个类别时，原始类称为基类，继承类称为派生类。
• class TableTennisPlayer //基类
• {
• }
• class RatedPlayer:public TableTennisPlayer //派生类
• {
• }
• 派生类具有以下特征：
• 派生类对象存储了基类的数据成员（派生类继承了基类的实现）;
• 派生类对象可以使用基类的方法（派生类集成了基类的接口）;
• 派生类需要自己的构造函数
• 派生类可以根据添加额外的数据成员和成员函数
• 在派生类的构造函数中，需要给派生类中的变量赋值，并且要给继承的变量赋值
• 派生类不能直接访问基类的私有成员，而必须通过基类方法进行访问
• RatedPlayer::RatedPlayer(unsigned int r,const string &fn,const string &ln,bool ht):TableTennisPlayer(fn, ln, ht) //派生类的构造函数以及给基类变量赋值
• {
• }
• 派生类的构造函数使用了基类的构造函数作为成员列表初始化。
  */

/*派生类和基类之间的特殊关系

• 派生类对象可以使用基类方法，条件是方法不是私有的
• 基类指针可以在不进行显式类型转换的情况下指向派生类对象，基类引用可以在不进行显式类型转换的情况下引用派生类对象
• 派生类指针或者引用只能用于调用派生类方法，因为派生类中可能存在基类中不存在的变量
  */

/*虚方法：关键字virtual

• 在方法前面添加该关键字，这些方法被称为虚方法（virtual method)
• 可以在派生类中重写基类的函数，这样使用不同类型的对象，将会调用不同的同名函数
• 使用情景：
• 在类的使用中可以将派生类赋值给基类的指针或者引用，如果方法没有添加关键字virtual,那么将会根据指针类型或者引用类型调用相应的方法，此时会调用基类中的方法，而如果添加关键字virtual,那么将会根据引用或者指针指向的对象的类型，调用相应的方法
• 需要在基类以及派生类中同名方法声明以及方法源码处都要添加virtual关键词
  */

/*继承关系is-a

• 继承关系：公有继承，私有继承和保护继承
• 公有继承，建立了一种is-a关系
• 派生类继承了基类的变量以及方法，但是派生类只能通过基类的公有方法访问基类的私有变量。
• 在派生类中使用基类方法和派生类方法
• void BrassPlus::ViewAcct() const
• {
• Brass::ViewAcct(); //使用基类方法
• }
• void BrassPlus::ViewAcct() const
• {
• ViewAcct(); //使用派生类方法
• }
• 基类水果：重量和热量
• 派生类香蕉：重量，热量和香蕉皮
• 这种关系是is-a关系，香蕉是一种水果
• 私有继承：建立了一种has-a的关系
• 午餐中有水果，但是不能从Fruit类中派生出Lunch类来在午餐中添加水果，但是可以将Fruit对象作为Lunch类的数据成员，这样就建立了一种has-a关系
• 保护继承：使用关键字protected，在类外只能用公有类成员来访问protected部分中的成员，而派生类成员可以直接访问基类的保护成员，但是不能直接访问基类的私有成员
• class Student:protected std::string, protected std::valarray
• {
• }
  */

/模板类/

/*共同的友元

• class Analyzer{};
• class Probe
• {
• friend void sync(Analyzer &a, const Probe &p)
• friend void sync(Probe &p, const Analyzer &a)
• }
• class Analyzer
• {
• friend void sync(Analyzer &a, const Probe &p);
• friend void sync(Probe &p, const Analyzer &a);
• }
• inline void sync(Analyzer &a, const Probe &p)
• {
• }
• inline void sync(Probe &p, const Analyzer &a)
• {
• }
  */

/嵌套类：将一个类声明放在另一个类中，在另一个类中声明的类被成为嵌套类，它通过提供新的类型类作用域来避免名称混乱。/

/*异常

• 处理异常情况std::abort(),abort函数位于头文件cstdlib,其典型实现是向标准错误流（即cerr使用错误流）发送消息abnormalprogram termination（程序异常终止），然后终止程序。
• 实现：
• std::cout << “Harmonic mean of” << x;
• std::abort();
• 异常机制
• try{
• }
• catch(const char *s)
• {
• std::cout << s << std::endl;
• continue;
• }
• catch关键字表示捕获异常，处理程序以关键字catch开头，随后是位于括号中的类型生命，它指出了异常处理程序要响应的异常类型，然后是一个花括号括起的代码块，指出要采取的措施。s表示一场类型，将匹配的异常赋值给s。
• 如果没有try块或者没有匹配的处理程序时，程序最终调用abort()函数。
  */

/*输入、输出和文件

• ostream
• istream
• iostream
  */

/*iomanip提供了一些控制符用于调整格式

• 常用的控制符，setprecision(),setfill(),setw()分别用来设置精度、填充字符和字段宽度。
• #include
• int main()
• {
• using namespace std;
• cout << setw(6) << setprecision(3) << setfill(‘.’);
• }
  */

/*cin进行输入

• cin或者cout对象包含一个描述流状态的数据成员，流状态由3个ios_base元素组成：eofbit\badbit\failbie,其中每个元素都是一位，可以是1或者0.
• cin操作到达文件末尾时，将设置eofbit
• cin读取未能读取到预期的字符时，将设置failbit，或者读取了不可访问的文件或试图写入开启写保护的磁盘时，将设置为failbit
• 当cin操作在一些无法诊断的失败破坏流时，badbit将被设置。
• 文件模式：
• ios_base::in 打开文件便于读取
• ios_base::out 打开文件便于写入
• ios_base::ate 打开文件，并移到文件尾
• ios_base::app 追加到文件尾
• ios_base::trunc 如果文件存在则截短文件
• ios_base::binary 二进制文件（以二进制模式打开ios_base::in | ios_base::binary）
• open()函数使用默认参数ios_base::in ios_base::out
• ofstream fout(“bagels.txt”, iod_base::out | ios_base::app);
• C++中 ifstream fin(filename, mode);
• read()和write()方法
• fout.write((char *) &pl, sizeof pl) pl地址
• 要使用read()来读取write()写入的数据
  */

/*随机存取

• 随机存取指的是直接移动到文件的任何位置。
• fstream类为此继承了两个方法：seekg()和seekp(),前者将输入指针移到制定的文件位置，后者将输出指针移到制定的文件位置。
• fin.seekg(30, ios_base::beg); 跳转到距离开始30bytes的位置
• fin.seekg(-1,ios_base::cur); 回跳一个byte
• fin.seekg(0, ios_base::end); 跳转到文件末尾
• fin.seekg(112); 文件指针指向第113个字节
• 检查文件指针的当前位置，则对输入流使用teelg()，对输出流使用tellp()方法，他们都会返回一个表示当前位置的streampos值（以字节为单位，从文件开始处算起）。
• 创建fstream对象时，输入指针和输出指针将一前一后地移动，因此tellg()和tellp()返回的值相同，然而，如果使用istream对子昂来管理输入流，使用ostream对象来管理同一个文件的输出流，则输入指针和输出指针将彼此独立地移动，因此tellg()和tellp()将返回不同的值。
  */

/内核格式化/