第七章 文件操作和模板
7.1 文件操作
1.数据的层次
- 位 bit
- 字节 byte
- 域/记录:
数据在计算机实质上被保存的就是一个个0,1的比特位。它是每位这样存放的。但是我们具体如果去处理每个比特位的话,那么很多时候数据在构建的时候会非常繁琐,并且具有很强的不规律性。
所以我们进一步就把这8个比特位构成的称之为字节。那么每一个byte对应描述了一定的内容,
而这些各个字节组成的一些具体的内容,我们又把它称之为域或者记录。
将所有记录顺序地写入一个文件—>顺序文件
2.文件和流
顺序文件 — 一个有限字符构成的顺序字符流
C++标准库中: ifstream, ofstream和fstream共3个类,用于文件操作 — 统称为文件流类
3.文件操作
4.建立顺序文件
- 也可以先创建 ofstream对象, 再用 open函数 打开
ofstream fout; fout.open( “test.out”, ios::out|ios::binary );
- 判断打开是否成功:
if(!fout) { cerr << “File open error!”<<endl; }
- 文件名可以给出绝对路径, 也可以给相对路径 没有交代路径信息, 就是在当前文件夹下找文件
5.文件的读写指针
对于输入文件,有一个读指针
对于输出文件, 有一个写指针
对于输入输出文件, 有一个读写指针
标识文件操作的当前位置,该指针在哪里,读写操作就在哪里进行
ofstream fout(“a1.out”, ios::app);
long location = fout.tellp(); //取得写指针的位置
location = 10L;
fout.seekp(location); // 将写指针移动到第10个字节处
fout.seekp(location, ios::beg); //从头数location
fout.seekp(location, ios::cur); //从当前位置数location
fout.seekp(location, ios::end); //从尾部数location
location 可以为负值
6.二进制文件读写
• 在Unix/Linux下, 二者一致, 没有区别;
• 在Windows下, 文本文件是以 “\r\n”作为换行符
读出时, 系统会将0x0d0a只读入0x0a
写入时, 对于0x0a系统会自动添加0x0d
7.显式关闭文件
ifstream fin(“test.dat”, ios::in);
fin.close();
ofstream fout(“test.dat”, ios::out);
fout.close();
7.2 函数模板
1.泛型程序设计(Generic Programming)
算法实现时不指定具体要操作的数据的类型
泛型——算法实现一遍,适用于多种数据结构
两种类型
- 函数模板
- 类模板
2.函数模板
template<class 类型参数1, class 类型参数2, … >
返回值类型 模板名 (形参表)
{
函数体
}
例子,交换两个变量值的函数模板
template <class T>
void Swap(T & x,T & y)
{
T tmp = x;
x = y;
y = tmp;
}
int main(){
int n = 1, m = 2;
Swap(n, m); //编译器自动生成 void Swap(int &, int &)函数
double f = 1.2, g = 2.3;
Swap(f, g); //编译器自动生成 void Swap(double &, double &)函数
return 0;
}
函数模板可以重载,只要它们的形参表不同即可
下面两个模板可以同时存在:
template<class T1, class T2>
void print(T1 arg1, T2 arg2)
{
cout<< arg1 << " "<< arg2<<endl;
}
template<class T>
void print(T arg1, T arg2)
{
cout<< arg1 << " "<< arg2<<endl;
}
C++编译器遵循以下优先顺序:
- Step 1: 先找参数完全匹配的普通函数(非由模板实例化而得的函数)
- Step 2: 再找参数完全匹配的模板函数
- Step 3: 再找实参经过自动类型转换后能够匹配的普通函数
- Step 4: 上面的都找不到,则报错
template <class T>
T Max(T a, T b)
{
cout << "Template Max 1" <<endl;
return 0;
}
template <class T, class T2>
T Max(T a, T2 b)
{
cout << "Template Max 2" <<endl;
return 0;
}
double Max(double a, double b){
cout << "MyMax" << endl;
return 0;
}
int main()
{
int i=4, j=5;
Max(1.2,3.4); //调用Max(double, double)函数
Max(i, j); //调用第一个T Max(T a, T b)模板生成的函数
Max(1.2, 3); //调用第二个T Max(T a, T2 b)模板生成的函数
return 0;
}
赋值兼容原则引起函数模板中类型参数的二义性
template<class T>
T myFunction(T arg1, T arg2)
{
cout<<arg1<<“ ”<<arg2<<“\n”;
return arg1;
}
…
myFunction(5, 7); //ok: replace T with int
myFunction(5.8, 8.4); //ok: replace T with double
myFunction(5, 8.4); //error: replace T with int or double? 二义性
可以在函数模板中使用多个类型参数, 可以避免二义性
template<class T1, class T2>
T1 myFunction( T1 arg1, T2 arg2)
{
cout<<arg1<<“ ”<<arg2<<“\n”;
return arg1;
}
…
myFunction(5, 7); //ok:replace T1 and T2 with int
myFunction(5.8, 8.4); //ok: replace T1 and T2 with double
myFunction(5, 8.4); //ok: replace T1 with int, T2 with double
7.3 类模板
类模板的定义
template <类型参数表>
class 类模板名
{
成员函数和成员变量
};
类型参数表的写法就是:
class 类型参数1, class 类型参数2, …
类模板里的成员函数,若在类模板外面定义时:
template <型参数表>
返回值类型 <span style="color:#3333ff;">类模板名<类型参数名列表></span>::成员函数名(参数表)
{
……
}
用类模板定义对象的写法如下:
类模板名 <真实类型参数表> 对象名(构造函数实际参数表);
如果类模板有无参构造函数, 那么也可以只写:
类模板名 <真实类型参数表> 对象名;
示例
//Pair类模板:
template <class T1, class T2>
class Pair{
public:
<span style="white-space:pre"> </span>T1 key; //关键字
<span style="white-space:pre"> </span>T2 value; //值
<span style="white-space:pre"> </span>Pair(T1 k,T2 v):key(k),value(v) { };
<span style="white-space:pre"> </span>bool operator < (const Pair<T1,T2> & p) const;
};
template<class T1,class T2>
bool Pair<T1,T2>::operator<( const Pair<T1, T2> & p) const
//Pair的成员函数 operator <
{ return key < p.key; }
//Pair类模板的使用:
int main()
{
Pair<string, int> student("Tom",19);
//实例化出一个类 Pair<string, int>
cout << student.key << " " << student.value;
return 0;
}
输出结果:
Tom 19
使用类模板声明对象
- 编译器自动用具体的数据类型,替换类模板中的类型参数,生成模板类的代码
由类模板实例化得到的类叫模板类
- 为类型参数指定的数据类型不同, 得到的模板类不同
Pair<string, int> * p;
Pair<string, double> a;
p = & a; //wrong
函数模版作为类模板成员
#include <iostream>
using namespace std;
template <class T>
class A{
public:
template<class T2>
void Func(T2 t) { cout << t; } //成员函数模板
};
int main()
{
A<int> a;
a.Func('K'); //成员函数模板 Func被实例化
return 0;
}
程序输出:
K
要注意,类模板的类型参数,和成员函数模板的类型参数,是不能一致的。
若函数模板改为template <class T>void Func(T t){cout<<t}将报错 “declaration of ‘class T’shadows template parm ‘class T’ ”
类模板与非类型参数
类模板的参数声明中可以包括 非类型参数,如:template <class T, int elementsNumber>
- 非类型参数:用来说明类模板中的属性
- 类型参数:用来说明类模板中的属性类型,成员操作的参数类型和返回值类型
template <class T, int size>
class CArray{
T array[size];
public:
void Print( )
{
for(int i = 0; i < size; ++i)
cout << array[i] << endl;
}
};
CArray<double, 40> a2;
CArray<int, 50> a3;
注意:
CArray<int,40>和CArray<int,50>完全是两个类
这两个类的对象之间不能互相赋值
类模板与继承
模板类:类模板中类型/非类型参数示例化后的类
(1) 类模板从类模板派生template <class T1, class T2>
class A {
T1 v1; T2 v2;
};
template <class T1, class T2>
class B:public A<T2,T1>{
T1 v3; T2 v4;
};
template <class T>
class C:<strong>public</strong> B<T,T>{
T v5;
};
int main(){
B<int, double> obj1;
C<int> obj2;
return 0;
<pre name="code" class="cpp">};
obj1实例化:
class B<int, double>:public A<double, int>{ }
int v3; double v4;
};
class A<double, int> {
double v1; int v2;
};
(2) 类模板从模板类派生
也就是说,将一个具体的类从类模板里实例化,从这个实例化后的模板类里面,去派生一个类模板。
template <class T1, class T2>
class A { T1 v1; T2 v2; };
template <class T>
class B:public A<int, double> { T v; };
int main() { B<char> obj1; return 0; }
(3) 类模板从普通类派生
class A { int v1; };
template <class T>
class B:public A { T v; };
int main() {
B<char> obj1;
return 0;
}
7.4 string类
1.string类
- string 类 是一个模板类, 它的定义如下: typedef basic_string<char> string;
- 使用string类要包含头文件 <string>
- string对象的初始化:string s1("Hello"); // 一个参数的构造函数 字符串string s2(8, ‘x’); //两个参数的构造函数 整数+字符string month = “March”;
- 不提供以字符和整数为参数的构造函数
- 错误的初始化方法:string error1 = ‘c’; // 错string error2(‘u’); // 错string error3 = 22; // 错string error4(8); // 错
- 可以将字符赋值给string对象string s;s = ‘n’;
- 构造的string太长而无法表达,会抛出length_error异常
- string 对象的长度用成员函数 length()读取; string s("hello"); cout << s.length() << endl;
- string 支持流读取运算符 string stringObject; cin >> stringObject;
- string 支持getline函数 string s; getline(cin, s);
2.string的赋值和连接
- 用 ‘=’ 赋值 string s1("cat"), s2; s2 = s1;
- 用 assign成员函数复制 string s1("cat"), s3; s3.assign(s1);
- 用 assign成员函数部分复制 string s1("catpig"), s3; s3.assign(s1, 1, 3); //从s1 中下标为1的字符开始复制3个字符给s3
- 单个字符复制 s2[5] = s1[3] = ‘a’;
- 逐个访问string对象中的字符 string s1("Hello"); for(int i=0; i<s1.length(); i++) cout << s1.at(i) << endl; 成员函数at会做范围检查, 如果超出范围, 会抛出out_of_range异常, 而下标运算符不做范围检查
- 用 + 运算符连接字符串 string s1("good "), s2("morning! "); s1 += s2; cout << s1;
- 用成员函数 append 连接字符串 string s1("good "), s2("morning! "); s1.append(s2); cout << s1; s2.append(s1, 3, s1.size()); //s1.size(), s1字符数 开始位置的下标+个数 cout << s2; //下标为3开始, s1.size()个字符//如果字符串内没有足够字符, 则复制到字符串最后一个字符
3.比较string
- 用关系运算符比较string的大小 == , >, >=, <, <=, != 返回值都是bool类型, 成立返回true, 否则返回false
- 用成员函数compare比较string的大小
4.子串
- 成员函数 substr() string s1("hello world"), s2; s2 = s1.substr(4,5); //下标4开始5个字符 开始位置的下标+个数
5.交换string
- 成员函数 swap() string s1("hello world"), s2("really"); s1.swap(s2);
6.string的特性
- 成员函数 capacity() 返回无需增加内存即可存放的字符数
- 成员函数 maximum_size() 返回string对象可存放的最大字符数
- 成员函数 length()和size()相同 返回字符串的大小/长度
- 成员函数 empty() 返回string对象是否为空
- 成员函数 resize() 改变string对象的长度
7.寻找string中的字符
- 成员函数 find() string s1("hello world"); s1.find("lo"); //在s1中从前向后查找 “lo” 第一次出现的地方,如果找到, 返回 “lo”开始的位置, 即 l 所在的位置下标 //如果找不到, 返回 string::npos (string中定义的静态常量)
- 成员函数 rfind() string s1("hello world"); s1.rfind("lo"); //在s1中从后向前查找 “lo” 第一次出现的地方,如果找到, 返回 “lo”开始的位置, 即 l 所在的位置下标 //如果找不到, 返回 string::npos
- 成员函数 find_first_of() string s1("hello world"); s1.find_first_of(“abcd"); //在s1中从前向后查找 “abcd” 中任何一个字符第一次出现的地方,如果找到, 返回找到字母的位置; 如果找不到, 返回 string::npos
- 成员函数 find_last_of() string s1("hello world"); s1.find_last_of(“abcd"); //在s1中查找 “abcd” 中任何一个字符最后一次出现的地方,如果找到, 返回找到字母的位置; 如果找不到, 返回 string::npos
- 例子
string s1("hello worlld");
cout << s1.find("ll") << endl; <span style="font-family: Arial, Helvetica, sans-serif;">2</span>
cout << s1.find("abc") << endl; <span style="font-family: Arial, Helvetica, sans-serif;">4294967295 (常量)</span>
cout << s1.rfind("ll") << endl; <span style="font-family: Arial, Helvetica, sans-serif;">9</span>
cout << s1.rfind("abc") << endl; <span style="font-family: Arial, Helvetica, sans-serif;">4294967295</span>
cout << s1.find_first_of("abcde") << endl; <span style="font-family: Arial, Helvetica, sans-serif;">1</span>
cout << s1.find_first_of("abc") << endl; <span style="font-family: Arial, Helvetica, sans-serif;">4294967295</span>
cout << s1.find_last_of("abcde") << endl; <span style="font-family: Arial, Helvetica, sans-serif;">11</span>
cout << s1.find_last_of("abc") << endl; <span style="font-family: Arial, Helvetica, sans-serif;">4294967295</span>
cout << s1.find_first_not_of("abcde") << endl; <span style="font-family: Arial, Helvetica, sans-serif;">0</span>
cout << s1.find_first_not_of("hello world") << endl; <span style="font-family: Arial, Helvetica, sans-serif;">4294967295</span>
cout << s1.find_last_not_of("abcde") << endl; <span style="font-family: Arial, Helvetica, sans-serif;">10</span>
cout << s1.find_last_not_of("hello world") << endl; <span style="font-family: Arial, Helvetica, sans-serif;">4294967295</span>
8.替换string中的字符
- 成员函数erase()
string s1("hello worlld");
s1.erase(5); //保留长度为5 - 成员函数 find()
string s1("hello worlld");
cout << s1.find("ll", 1) << endl; //从下标1开始查找 - 成员函数 replace()
string s1("hello world");
s1.replace(2,3, “haha"); //将s1中下标2 开始的3个字符换成 “haha”
string s1("hello world");
s1.replace(2,3, "haha", 1,2); //将s1中下标2 开始的3个字符换成 “haha” 中下标1开始的2个字符
9.在string中插入字符
- 成员函数 insert()
string s1(“hello world”);
string s2(“show insert”);
s1.insert(5, s2); // 将s2插入s1下标5的位置
s1.insert(2, s2, 5, 3); //将s2中下标5开始的3个字符插入s1下标2的位置
10.转换成C语言式char *字符串
- 成员函数 c_str()
string s1("hello world");
printf("%s\n", s1.c_str());// s1.c_str() 返回传统的const char * 类型字符串且该字符串以 ‘\0’ 结尾 - 成员函数data()
string s1("hello world");
const char * p1=s1.data();
for(int i=0; i<s1.length(); i++)
printf("%c",*(p1+i));
//s1.data() 返回一个char * 类型的字符串,对s1 的修改可能会使p1出错。 - 成员函数copy()string s1("hello world");
int len = s1.length();
char * p2 = new char[len+1];
s1.copy(p2, 5, 0);
p2[5]=0;
cout << p2 << endl;
// s1.copy(p2, 5, 0) 从s1的下标0的字符开始,制作一个最长5个字符长度的字符串副本并将其赋值给p2,返回值表明实际复制字符串的长度
7.5 输入和输出
1.与输入输出流操作相关的类
istream是用于输入的流类,cin就是该类的对象。
ostream是用于输出的流类,cout就是该类的对象。
ifstream是用于从文件读取数据的类。
ofstream是用于向文件写入数据的类。
iostream是既能用于输入,又能用于输出的类。
fstream 是既能从文件读取数据,又能向文件写入数据的类。
2.标准流对象
输入流对象: cin 与标准输入设备相连
输出流对象:cout 与标准输出设备相连
cerr 与标准错误输出设备相连
clog 与标准错误输出设备相连
cin对应于标准输入流,用于从键盘读取数据,也可以被重定向为从文件中读取数据。
cout对应于标准输出流,用于向屏幕输出数据,也可以被重定向为向文件写入数据。
cerr对应于标准错误输出流,用于向屏幕输出出错信息,clog对应于标准错误输出流,用于向屏幕输出出错信息,
cerr和clog的区别在于cerr不使用缓冲区,直接向显示器输出信息;而输出到clog中的信息先会被存放在缓冲区,缓冲区满或者刷新时才输出到屏幕。
freopen("test.txt","w",stdout); //将标准输出重定向到 test.txt文件
3.判断输入流结束
可以用如下方法判输入流结束:
int x;
while(cin>>x){
…..
}
return 0;
istream &operator >>(int a)
{
…….
return *this ;
}
这个表达式它的返回值虽然是cin 但是在istream里面有一个强制类型转换运算符的重载就能够把这个cin对象强制转换成类型的值。所以当输入流结束的时候,这个cin被转换出来的布尔类型的值就是false。
如果从键盘输入,则在单独一行输入Ctrl+Z代表输入流结束
4.istream类的成员函数
istream & getline(char * buf, int bufSize);
从输入流中读取bufSize-1个字符到缓冲区buf,或读到碰到‘\n’为止(哪个先到算哪个)。
istream & getline(char * buf, int bufSize,char delim);
从输入流中读取bufSize-1个字符到缓冲区buf,或读到碰到delim字符为止(哪个先到算哪个)。
两个函数都会自动在buf中读入数据的结尾添加\0’。
输入流里的‘\n’或delim都不会被读入buf,但会被从输入流中取走。
如果输入流中‘\n’或delim之前的字符个数达到或超过了bufSize个,就导致读入出错,其结果就是:虽然本次读入已经完成,但是之后的读入就都会失败了。
可以用 if(!cin.getline(…)) 判断输入是否结束
- bool eof(); 判断输入流是否结束
- int peek(); 返回下一个字符,但不从流中去掉.
- istream & putback(char c); 将字符ch放回输入流
- istream & ignore( int nCount = 1, int delim = EOF ); 从流中删掉最多nCount个字符,遇到EOF时结束。