PKU C++程序设计实习学习笔记5 文件操作和模板

最新推荐文章于 2021-12-16 15:51:14 发布

buxizhizhou530

最新推荐文章于 2021-12-16 15:51:14 发布

阅读量1.2k

点赞数

分类专栏： C/C++ 文章标签： c++ 面向对象文件操作模板

本文链接：https://blog.csdn.net/buxizhizhou530/article/details/45541391

版权

C/C++ 专栏收录该内容

28 篇文章 2 订阅

订阅专栏

第七章文件操作和模板

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.二进制文件读写

Note -- 文本文件/二进制文件打开文件的区别:
• 在Unix/Linux下, 二者一致, 没有区别;
• 在Windows下, 文本文件是以 “\r\n”作为换行符
读出时, 系统会将0x0d0a只读入0x0a
写入时, 对于0x0a系统会自动添加0x0d

ifstream对象的gcount函数可以得到刚才读入的字节数。

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 类模板

类模板的定义

C++的类模板的写法如下:

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; }

自动生成两个模板类：A<int, double>和B<char>

(3) 类模板从普通类派生

class A { int v1; };

template <class T>
class B:public A { T v; };

int main() {
B<char> obj1;
return 0;
}

(4)普通类从模板类派生

template <class T>class A { T v1; int n; };class B: public A<int> { double v; };int main() { B 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。

如果是从文件输入，比如前面有freopen(“some.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时结束。

5.流操纵算子

buxizhizhou530

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
PKU C++程序设计实习学习笔记5 文件操作和模板

第七章文件操作和模板7.1 文件操作7.2 函数模板泛型程序设计(Generic Programming)算法实现时不指定具体要操作的数据的类型泛型——算法实现一遍，适用于多种数据结构优势: 减少重复代码的编写两种类型函数模板类模板与“抽象、封装、继承、多态”并列函数模板template
复制链接

扫一扫