6.6-6.7C++primeplus P137-P166

content

• 1.if else 语句
• 2.逻辑表达式
• 3.将枚举量作为标签
• 4.读取数字的循环
• 5.简单文件的输入输出

1.if else 语句

if else语句是C和C++里面的基本语法，非常重要。
注意一下if和else的控制范围。

1. 如果if后面只接了一句话，那么不需要大括号
2. 如果if后面不只一句话，那么需要一个大括号把所有语句括起来

#include<iostream>
using namespace std;

int main()
{
	int a=5;
	if(a==5)  //后面只接一句话
		cout<<a<<endl;
	else   //后面只接一句话
		cout<<"a!=5"<<endl;
	return 0;
}

值得一提的是，什么才算作一句话？很显然，在汉字中，一个句号结尾就是一句话，那么在C++中，一个‘;’结尾就算一句话结束。所以，

int main()
{
	int a = 5;
	if (a == 5)
		cout << a<<endl, a = 6, cout << a<<endl;  //这只算一句话
	else
		cout << "a!=5"<<endl, a = 5, cout << a;   //这也是
	return 0;
}

再来说，如果一个if后面接了不只一句话，那么需要大括号

int main()
{
	int a = 5;
	if (a == 5)
		{
			a=6;  //第一句话
			cout<<a<<endl;   //第二句话
		}
	else
		cout << "a!=5"<<endl, a = 5, cout << a;
	return 0;
}

2.逻辑表达式

C++的逻辑表达式有三种：逻辑OR（||），逻辑AND（&&），逻辑NOT（!)

(1)逻辑OR（||）
or的意思就是’或‘,当两个或两个以上的条件中有一个条件满足某个要求的时候，就用or，意思是，只要有一个条件是true，那么表达式就是true。且，表达式里面的判定是从左往右的，如果左边已经做出了有效判断，那么后面就不需要继续判断了，减少运算步骤。

5==5||5==9  //当判断到前面部分’5==5’就会结束运算。因为‘5==5’为true
5>3||5>10  //判断‘5>3'之后结束判断
5>8||5<3   

显然，上面的表达式没有添加扩号，这说明，逻辑运算符的优先级小于’==‘。
值得一提的是，C++规定，||运算符是一个顺序点，什么是顺序点呢看下面例子；

i++<6||i==j   //那么顺序点就是，先左边，后右边，上面提到了。那么这个表达式的顺序就是，先判断i<6，然后i+1，然后再去和||右边判定

(2)逻辑AND（&&）
1.当两个条件同时是true，表达式才是true，否则就是false。
2.&&运算符优先级小于关系运算符‘==’

(3)逻辑NOT（！）

！运算符将它后面的表达式取反

重点!!

疑难杂症来了！
单纯使用一个&&和||都是很简单明显的事情。那么配合使用逻辑运算符和一次性使用多个逻辑运算符怎么办呢？

1. 首先，对于同一个逻辑运算符，可以有很多个关系元。
   比如（1||2||0||1||3),这里看到有4个||逻辑运算符，这也是成立的，且还是从左往右判断。

2. 一个表达式同时有&&和||，那么先要知道的是，&&的优先级别高于||级别。也就是说（0&&1||1&&2),这个表达式会先执行完两边的&&，然后在执行||。

3.将枚举量作为标签

通常，cin无法识别枚举类型（它不知道程序员如果定义他们的）。但是当int型变量和枚举量进行比较的时候，枚举量会被转换为int。

下面是一个程序

#include<iostream>
using namespace std;
enum {red,orange,yellow,green,blue,violet,indigo};
int main()
{
	cout<<"Enter color code(0-6);";
	int code;
	cin>>code;
	while(code>=red&&code<=indigo)
	{
		switch(code)
		{
			case red:cout<<"red\n";break;
			case orange:cout<<"orange\n";break;
			case yellow:cout<<"yellow\n";break;
			case green:cout<<"grean\n";break;
			case blue:cout<<"blue\n";break;
			case violet:cout<<"violet\n";break;
			case indigo:cout<<"indigo\n";break;
		}
		cout<<"Enter color code(0-6):";
		cin>>code;
	}
	return 0;
}

4.读取数字的循环

假设要编写一个将一系列数字读入到数组中的程序，并且允许在数组填满之前结束输入，有很多方法。

1. 设置哨兵字符
2. 使用ctrl+z+回车键告诉cin到了文件尾，也就是设置eof，此后cin不再读取直到使用cin.clear()将eofbit和failbit都设置为0(重置输入流）

那么这里演示新的方法。

int n;
cin>>n;

如果用户输入的不是数字而是一个单词，那么会怎么样？

1. n的值保持不变
2. 不匹配的输入将被留在输入队列
3. cin对象中的一个错误标记被设置
4. 对cin方法的调用将返回false(如果被转换为bool类型）

方法返回false意味着可以用非数字来结束读取数字的循环。非数字输入设置错误标记意味着必须重置标记，程序才能继续读取输入。clear()方法重置错误输入标记，同时也重置文件尾。输入错误和EOF都将导致cin返回false；

实际上，如果对int类型输入了字符类型的变量。那么cin将会阻断输入，并且设置failbit为0.那么此时就需要使用cin.clear()来恢复畅通状态，然后使用cin.get()消化刚刚的字符。

#include<iostream>
using namespace std;

int main()
{
 int a;
 cout<<"输入一个字母:"<<endl;
 cin>>a;  //int型变量中放了char型数据,failbit置1
 cout<<"cin.fail()="<<cin.fail()<<endl;    //输出1

 //cin.clear();
 //cin.sync();
 cout<<"输入一个数字:"<<endl;    //由于failbit值为1,输入流不能正常工作
 cin>>a;                         //故此处的输入无效
 cout<<a<<endl;                  //输出不确定值

 cin.clear();                    //此处用cin.clear()流标志复位
 //cin.sync();
 cout<<"cin.fail()="<<cin.fail()<<endl;        //此处failbit已为0

 cout<<"输入一个数字:"<<endl;
 //但刚才输入的字符并没有从流中清除,所以cin>>a又把那个字符放入a中,流输入流又不能正常工作
 cin>>a;
 cout<<a<<endl; //输出不确定值
 cout<<"cin.fail()="<<cin.fail()<<endl;    //在此处failbit又为1

 cin.clear();            //再次修复输入流
 cin.ignore();            //取走刚才流中的字符
 cout<<"输入一个数字:"<<endl;    //再次接收用记输入,这次输入数字,正常输出了
 cin>>a;
 cout<<"a="<<a<<endl;
 //现在再看一下输入流的failbit
 cout<<"cin.fail()="<<cin.fail()<<endl;//输出0,表明输入流已恢复正常
 return 0;
}

因此可以总结一下，如果本来要输入int变量，结果输入char字符，要使用cin.clear()恢复failbit位，再将这个字符删除，删除字符可以使用cin.get()和cin.ignore()。

再精炼一点：

1. 重置cin以接受新的输入（clear（））
2. 删除错误的输入（ignore或者get）
   3.再输入

先看一个程序

#include<iostream>
using namespace std;

int main()
{
	int golf[5];
	cout << "请输入得分：\n";
	cout << "你需要输入5个得分：\n";
	int i;
	for (int i = 0; i < 5; i++)
	{
		cout << "round #" << i + 1 << ":";
		while (!(cin >> golf[i]))   //如果cin被阻塞，那么使用clear来恢复状态位,然后吃掉违反字符，
		{
			cin.clear();
			while (cin.get() != '\n')
				continue;
			cout << "请输入得分:\n";
		}
	}
	double total = 0.0;
	for (int i = 0; i < 5; i++)
		total += golf[i];
	cout << "arvrage=" << total / 5;
	return 0;
		
	
}

这显然，当输入变量不符合定义变量的时候，cin将会阻塞，那么cin的返回值就是false，那么此时就需要使用cin.clear()来恢复状态，再吃掉后面的字符，回车也吃掉.意思是吃掉该行的所有字符，从下一行开始重新输入.

5.简单文件的输入输出

1.什么是文件IO？

IO就是input/output，输入输出。文件IO就是读写文件。

2.文件 *** 作的主要接口API

（1）API是一些函数，这些函数是由linux系统提供支持的，由应用程序程序来使用。
（2）应用层程序通过调用API来调用 *** 作系统中的各种功能来干活。
（3）学习一个 *** 作系统，其实就是学习这个 *** 作系统的API.

3.常用的文件IO接口
open、close、write、read
4.文件 *** 作的一般步骤

（1）一般先open打开一个文件，得到文件描述符，在对文件进行读写 *** 作，完成读写文件后最后close关闭文件，以免造成文件损坏。

（2）文件平时是存在块设备中的文件系统中，我们把这种文件叫静态文件。当我们去open打开一个文件时，linux内核做的 *** 作包括：内存在进程中建立一个打开文件的数据结构，记录下我们打开的这个文件；内核在内存中申请一段内存，并且将静态文件的内容从块设备中读取到内存中特定的地址管理存放（叫动态文件）。

（3）打开文件后，对文件的读写 *** 作都是针对动态文件进行 *** 作。当我们对动态文件 *** 作完成后，此时内存中的动态文件和设备快中的静态文件就不同步了，当我们close关闭动态文件时，close内部内核将内存中的动态文件的内容同步到块设备中的静态文件。

那么很显然，如果不关闭动态文件，那么在此之前的所有对文件的 *** 作都是做无用功。所以关闭文件这一步显得格外重要

(1)写入到文本文件
对于文件输出，C++使用类似于cout的东西。下面是一些有关将cout用于控制台输出的基本事实：

• 必须包含头文件iostream
• 头文件iotream定义了一个用于处理输出的ostream类
• 要指明名称空间std；
• 可以结合使用cout和运算符<<来输出各种类型的数据

文件输出于此类似

• 必须包含头文件fstream
• 头文件fstream也声明了一个用于处理输出的ofstream类
• 需要声明一个或者多个ofstream变量，并以自己喜欢的方式对其命名。
• 必须指明名称空间std
• 需要将ofstream对象与文件关联起来。
• 使用完文件后，要用close()关闭
• 可以结合ofstream对象和运算符<<来输出各种类型的数据

总结：将数据写入文本的方法如下：

1. 包含头文件fstream
2. 创建一个oftream对象
3. 将该ofstream对象与同一个文件关联起来
4. 就像使用cout那样使用ofstream

但是值得一提的是：cout是将输入的内容显示到屏幕上，而ofstream的对象是将输入的内容写入文件

#include<iostream>
#include<fstream>

using namespace std;

int main()
{
	char automobile[50];
	int year;
	double a_price;
	double d_price;

	ofstream outfile;
	outfile.open("lby.txt");
	cout << "输入model的名字：";
	cin.getline(automobile, 50);
	cout << "输入年份:";
	cin >> year;
	cout << "输入价格：";
	cin >> a_price;
	d_price = 0.913 * a_price;

	cout << fixed;
	cout.precision(2);
	cout.setf(ios_base::showpoint);
	cout << "名字：" << automobile << endl;
	cout << "年份：" << year << endl;
	cout << "价格：" << a_price << endl;
	cout << "现在价格：" << d_price << endl;


	outfile << fixed;
	outfile.precision(2);
	outfile.setf(ios_base::showpoint);
	outfile << "名字：" << automobile << endl;
	outfile << "年份：" << year << endl;
	outfile << "价格：" << a_price << endl;
	outfile << "现在价格：" << d_price << endl;
	outfile.close();
	return 0;
}

看完这个程序会发现cout和fileout的使用方法一样，这有一个大胆猜想，模仿这两个函数是一样的？难道这两个函数的类是继承关系吗？

1.类型ifstream和istringstream都继承自istream：因此我们可以像使用istream对象一样来使用ifstream和istringstream对象。也就是说，我们是如何使用cin的，就可以同样地使用这些类型的对象。例如，可以对一个ifstream或istringstream对象调用getline，也可以使用>>从一个ifstream或istringstream对象中读取数据

2.类似的，ofstream和ostringstream都继承自ostream：因此我们是如何使用cout的，就可以同样地使用这些类型的对象

(2)读取文本文件

文本的输入是基于控制台输入的。控制台输入基于多个方面，

• 头文件必须包含iostream
• 头文件iostream定义了一个用于处理输入的istream类
• 头文件iostream声明了一个名为cin的istream变量（对象）
• 必须指明名称空间std；例如，为引用元素cin，必须使用编译指令using
• 可以结合使用cin和运算符>>来读取各类型的数据
• 对象cin本身被用作测试条件的时候，如果最后一个读取 *** 作成功，它将被转换为bool值

文件输入与此类似

• 必须包含头文件fstream
• 头文件fstream定义了一个用于处理输入的ifstream类
• 必须指明名称空间std
• 需要将ifstream对象与文件关联起来。用open（）方法
• 使用完文件后用close（）关闭

下面一个小程序帮助理解

#include<iostream>
#include<fstream>
#include<cstdlib>  //支持exit（）函数
using namespace std;

int main()
{
	char filename[100];
	ifstream inFile;
	cout<<"输入文件名称：";
	cin.getline(filename,100);
	inFile.open(filename);   //关联文件
	if(!inFile.is_open())   //is_open()函数检查文件是否打开
	{
		cout<<"Could not open the file"<<filename<<endl;
		cout<<"Program ternating.\n";
		exit(EXIT_FAILURE);  //终止程序
	}
	double value;
	double sum=0.0;
	int count=0;
	
	inFile>>value;
	while(inFile.good())
	{
		++count;
		sum+=value;
		inFile>>value;
	}
	if(inFile.eof())
		cout<<"End of file reached.\n";
	else if(inFile.fail())
		cout<<"Input terminated by data mismatch.\n";
	else
		cout<<"input terminated for unknow reason.\n";
	if(count==0)
		cout<<"No data processed";
	else
	{
		cout<<"Items read:"<<count<<endl;
		cout<<"Sum: "<<sum<<endl;
		cout<<"Average: "<<sum/count<<endl;
	}
	inFile.close();
	return 0;
}

判断文件中断读出的原因至关重要，所以设置很多if——else来判断到底是哪里出了问题。方法good（）返回true说明没有问题，否则就有问题.

这次学习主要简单看了一下io，认识io。接下来的学习会深入探讨io。