C++文件操作和模板

1、数据层次

位 bit

字节 byte

域/记录

将所有记录顺序地写入一个文件---->顺序文件：一个有限字符构成的顺序字符流

C++标准库中：ifsteam,ofstream,fstream三个类

2、文件操作

打开文件---->读/写文件---->关闭文件

class CSstudent{
public:
    char szName[20];
    int nScore;
};

int main(){
    CSstudent s;
    ofstream OutFile("a.dat",ios::out|ios::binary);
    while(cin>>s.szName>>s.nScore){
        if(strcmp(s.szName,"exit")==0) break;
        OutFile.write((char*)&s, sizeof(s));
    }
    OutFile.close();
    ifstream InFile("a.dat",ios::in|ios::binary);
    if(!InFile){
        cout<<"Error"<<endl;
        return 0;
    }
    while(InFile.read((char*)&s, sizeof(s))){
        int nReadedBytes = InFile.gcount();
        cout<<s.szName<<" "<<s.nScore<<endl;
    }
    InFile.close();
    return 0;
}

改变程序中学生名字：

int main(){
    CStudent s;
    fstream iofile( “c:\\tmp\\students.dat”, ios::in|ios::out|ios::binary);
    if(!iofile) {
        cout << "error" ;
        return 0;
    }
    iofile.seekp( 2 * sizeof(s), ios::beg); //定位写指针到第三个记录
    iofile.write( “Mike”, strlen("Mike")+1);
    iofile.seekg(0, ios::beg); //定位读指针到开头
    while( iofile.read( (char* ) & s, sizeof(s)) )
        cout << s.szName << " " << s.nScore << endl;
    iofile.close();
    return 0;
}

文件拷贝：

//用法示例：
//mycopy src.dat dest.dat
//即将 src.dat 拷贝到 dest.dat
//如果 dest.dat 原来就有, 则原来的文件会被覆盖

#include <iostream>
#include <fstream>
using namespace std;
int main(int argc, char * argv[]){
    if(argc != 3) {
        cout << "File name missing!" << endl;
        return 0;
    }
    ifstream inFile(argv[1], ios::binary|ios::in); //打开文件用于读
    if(! inFile) {
        cout << “Source file open error.” << endl;
        return 0;
    }
    ofstream outFile(argv[2], ios::binary|ios::out); //打开文件用于写
    if(!outFile) {
        cout << “New file open error.” << endl;
        inFile.close(); //打开的文件一定要关闭
        return 0;
    }
    char c;
    while(inFile.get(c)) //每次读取一个字符
        outFile.put(c); //每次写入一个字符
    outFile.close();
    inFile.close();
    return 0;
}

 3、函数模板

（1）泛型程序设计

算法实现时不指定具体要操作的数据的类型，适用于多种数据结构，以减少重复代码的编写。

使用模板：函数模板+类模板

（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>
T2 print(T1 arg1, T2 arg2)
{
    cout<< arg1 << " "<< arg2<<endl;
    return arg2;
}

函数模板也可以重载，只要他们的形参表不同即可。例如：

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: 上面的都找不到, 则报错

Note：赋值兼容原则引起函数模板中类型参数的二义性

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

 4、类模板

定义一批相似的类---->定义类模板---->生成不同的类

template <类型参数表>
class 类模板名 {
    成员函数和成员变量
};

template <型参数表>
返回值类型 类模板名<类型参数名列表>::成员函数名(参数表)
{
 ……
}

用类模板定义对象的写法如下: 类模板名 <真实类型参数表> 对象名(构造函数实际参数表);

如果类模板有无参构造函数, 那么也可以只写: 类模板名 <真实类型参数表> 对象名;

template <class T1, class T2>
class Pair{
public:
    T1 key; //关键字
    T2 value; //值
    Pair(T1 k,T2 v):key(k),value(v) { };
    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; }

int main()
{
    Pair<string, int> student("Tom",19);
    //实例化出一个类 Pair<string, int>
    cout << student.key << " " << student.value;
    return 0;
}

Note：编译器由类模板生成类的过程叫类模板的实例化。

　　　由类模板实例化得到的类叫模板类。

类模板的参数声明中可以包括非类型参数 

template<class T, int elementsNum>

• 非类型参数: 用来说明类模板中的属性

• 类型参数: 用来说明类模板中的属性类型, 成员操作的参数类型和返回值类型

类模板与继承：

类模板派生出类模板

模板类 (即类模板中类型/非类型参数实例化后的类)派生出类模板

普通类派生出类模板

模板类派生出普通类

5、string类

（1）string类是一个模板类，使用需加头文件<string>：

typedef basic_string<char> string;

string s1("Hello"); // 一个参数的构造函数
string s2(8, ‘x’); // 两个参数的构造函数
string month = “March”; 

//错误的初始化方法：
string error1 = ‘c’; // 错，‘c’是单字符不可以；"c"是字符串，后面有结束符，可以
string error2(‘u’); // 错 
string error3 = 22; // 错
string error4(8); // 错

//可以将字符赋值给string对象,但不能初始化
string s;//可以
s = ‘n’;

构造的string太长会抛出length_error异常。

长度用length()读取。

支持流读取运算符：

string str;
cin>>str;

支持getline函数：

string s;
getline(cin, s);

（2）string赋值：“=”，assign：

string s1("catpig"), s2, s3;
s2 = assign(s1);
s3 = assign(s1, 0, 2);

单个字符复制：s2[5] = s1[3] = ‘a’;

逐个访问string对象中的字符：成员函数at会做范围检查, 如果超出范围, 会抛出out_of_range异常, 而下标运算符不做范围检查。

string s1("Hello");
for(int i=0; i<s1.length(); i++)
    cout << s1.at(i) << endl;

（3）string连接

用 + 运算符连接字符串，用成员函数 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()个字符
//如果字符串内没有足够字符, 则复制到字符串最后一个字符

（4）string比较

用关系运算符比较string的大小 == , >, >=, <, <=, != 。返回值都是bool类型, 成立返回true, 否则返回false。

两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇’\0’为止。

或使用compare成员函数比较大小：

int f1 = s1.compare(s2);

（5）子串成员函数 substr()

string s1("hello world"), s2;
s2 = s1.substr(4,5); //下标4开始5个字符
cout << s2 << endl; //输出o wor 

（6）

交换函数swap()

s1.swap(s2); 

成员函数 capacity()

返回无需增加内存即可存放的字符数

成员函数maximum_size()

返回string对象可存放的最大字符数

成员函数length()和size()相同

返回字符串的大小 /长度

成员函数empty()

返回string对象是否为空

成员函数resize()

改变string对象的长度

(7)寻找string中的字符

find()//在s1中从前向后查找 “lo” 第一次出现的地方 //如果找到, 返回 “lo”开始的位置, 即 l 所在的位置下标 //如果找不到, 返回 string::npos (string中定义的静态常量)

rfind()//在s1中从后向前查找 “lo” 第一次出现的地方 //如果找到, 返回 “lo”开始的位置, 即 l 所在的位置下标 //如果找不到, 返回 string::npos

find_first_of()//在s1中从前向后查找 “abcd” 中任何一个字符第一次出现的地方 //如果找到, 返回找到字母的位置; 如果找不到, 返回 string::npos

find_last_of()//在s1中查找 “abcd” 中任何一个字符最后一次出现的地方 //如果找到, 返回找到字母的位置; 如果找不到, 返回 string::npos

find_first_not_of()//在s1中从前向后查找不在 “abcd” 中的字母第一次出现的地方 //如果找到, 返回找到字母的位置; 如果找不到, 返回 string::npos

find_last_not_of()//在s1中从后向前查找不在 “abcd” 中的字母第一次出现的地方 //如果找到, 返回找到字母的位置; 如果找不到, 返回 string::npos

(8)各种成员函数

string s1("hello worlld");
 s1.erase(5);
 cout << s1;
 cout << s1.length();
 cout << s1.size();
// 去掉下标 5 及之后的字符

string s1("hello worlld");
cout << s1.find("ll", 1) << endl;
cout << s1.find("ll", 2) << endl;
cout << s1.find("ll", 3) << endl;
//分别从下标1, 2, 3开始查找 “ll”

string s1("hello world");
s1.replace(2,3, “haha");
cout << s1;
//将s1中下标2 开始的3个字符换成 “haha”
输出:
hehaha world

string s1("hello world");
s1.replace(2,3, "haha", 1,2);
cout << s1;
//将s1中下标2 开始的3个字符
//换成 “haha” 中下标1开始的2个字符
输出:
heah world

string s1(“hello world”);
string s2(“show insert”);
s1.insert(5, s2); // 将s2插入s1下标5的位置
cout << s1 << endl;
s1.insert(2, s2, 5, 3);
//将s2中下标5开始的3个字符插入s1下标2的位置
cout << s1 << endl;
输出:
helloshow insert world
heinslloshow insert world

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出错。
输出:
hello world

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
//返回值表明实际复制字符串的长度
输出:
hello

6、输入输出

（1）标准流对象

cin对应于标准输入流，用于从键盘读取数据，也可以被重定向为从文件中读取数据。

cout对应于标准输出流，用于向屏幕输出数据，也可以被重定向为向文件写入数据。

cerr对应于标准错误输出流，用于向屏幕输出出错信息。

clog对应于标准错误输出流，用于向屏幕输出出错信息。

cerr和clog的区别在于cerr不使用缓冲区,直接向显示器输出信息；而输出到clog中的信息先会被存放在缓冲区,缓冲区满或者刷新时才输出到屏幕。

（2）重定向

freopen("test.txt","w",stdout); //将标准输出重定向到 test.txt文件

freopen(“t.txt”,“r”,stdin); //cin被改为从 t.txt中读取数据 

（3）判断输入流结束

int x;
while(cin>>x){
…..
}

如果从文件输入，比如前面有freopen(“t.txt”,“r”,stdin);那么读到文件尾部，算输入结束。

如果从键盘输入，则在单独一行输入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时结束。

#include <iostream >
using namespace std;
int main() {
int x;
char buf[100];
cin >> x;
cin.getline(buf,90);
cout << buf << endl;
return 0;
}
输入：
12 abcd↙
输出：
abcd (空格+abcd)
输入
12↙
程序立即结束，输出：
12
因为getline读到留在流中的’\n’就会返回