C++ day6 循环，关系表达式（二）

傷城~ 2023-07-10 13:00 22阅读 0赞

### 文章目录 ###

*  循环读取文本
 *   *  示例1 cin忽略空白符是个问题
     *  示例2 用cin.get(char)替代cin解决问题（引用类型）
     *   *  初窥函数重载
     *  文件尾 EOF（程序和操作系统协作）
     *   *  示例3 用EOF结束输入
         *  每次读取一个字符，直到遇到EOF 的while循环基本设计（精，利用cin.get(char)的返回值）
         *   *  示例 修改上一个示例
 *  嵌套循环非常适合处理二维数组
 *   *  示例1 像表格一样输出二维数组
     *  示例2 cout遇到char指针会打印字符串
 *  练习

# 循环读取文本 #

用循环一个一个地读取字符是循环的一大用武之地

## 示例1 cin忽略空白符是个问题 ##

用\#作为哨兵字符（sentinel character）

哨兵字符就是告诉程序停止读取字符的字符，下面这个示例和以前的C一样，用特殊字符\#来终止输入，只是C和C++的I/O工具不太一样，但是如果你想输入\#，这样做就不行了

另外一个很大很大的弊病是：cin忽略了空格，换行符，制表符这些空白符，输出不显示，计数也不计算

#include <iostream>
    int main()
    { 
        using std::cin;
        using std::cout;
        using std::endl;
    
        char ch;
        int count = 0;
        cout << "Enter characters:(# to quit)\n";
        cin >> ch;
        while(ch != '#')
        { 
            cout << ch;
            ++count;//这里和count++毫无区别
            cin >> ch;
        }
        cout << endl << count << " characters read.\n";
    
        return 0;
    }

Enter characters:(# to quit)
    abcdefg hijklmn opq #rst uvwxyz #
    abcdefghijklmnopq
    17 characters read.

a后面是空格，b后面是水平制表符，c后面是换行符，注意输入换行符自动回显了前面输入的三个非空白符，但是还可以继续接收输入，于是我输入d后就输入了\#，再回车时只回显了新输入的d,并且计数只有4，即abcd,所有空白符都没有回显和计数

这是cin本身的特性造成的

Enter characters:(# to quit)
    a b     c
    abcd#
    d
    4 characters read.

## 示例2 用cin.get(char)替代cin解决问题（引用类型） ##

把上面程序的cin >> ch;替换为

cin.get(ch);

还像上面那样输入，但是可以看到三种空白符斗回显了，也计数了

Enter characters:(# to quit)
    a b     c
    a b     c
    d#
    d
    7 characters read.

cin.get(char)方法解决了这个问题，但是如果我们深入思考一下，在C语言里，想要通过函数改变一个变量的值，必须**把变量的地址（指针）传给函数**，光传变量本身是没用的，因为传变量本身，使用的是变量的副本，但是这里只传了ch,不是&ch,也把ch的值改变了，这是因为头文件iostream把cin.get()方法的参数被声明为引用类型！他是**C++在C基础上新增的一种类型。**

我很惭愧我没注意到这一点。

### 初窥函数重载 ###

函数重载就是函数的名字相同，但是参数列表不同。所以很简单也很好理解为什么需要他，因为只要可以区分开，用同一个名字又有什么大不了的嘛，而且其实用同一个名字也是有目的的，表明这几个参数列表不同的函数做的事情是一样的，只是针对不同数据类型。

比如上面使用cin的get()方法，加上之前第四章有一种方式，共三种：

//不要参数,cin.get()
    char ch;
    ch = cin.get();//返回输入队列中的一个字符，以int值返回，类似于C的类函数宏getchar()
    
    //一个char类型的参数，cin.get(char)
    char ch;
    cin.get(ch);//返回的是一个cin对象
    
    //两个参数，分别是char*和int类型,cin.get(char *, int )
    char *name;
    const int Arsize = 10;
    cin.get(name, Arsize);

根据你使用get方法时输入的参数的数目和类型，C++就知道你到底是要调用哪一个版本的get方法啦

好简单,但是细节也很多，如果不注意细节，比如cin.get()对类型的要求（返回的int类型数值），也容易糊涂。

注意istream类的cin对象在需要bool值的地方会被自动被转换为bool  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]

这两个方法下面还有一些介绍，但是使用cin.get(char)更符合对象方式。毕竟他返回的就是一个对象。而且正因为返回的是cin对象，所以可以拼接调用这个函数

char ch1, ch2;
    cin.get(ch1).get(ch2);

## 文件尾 EOF（程序和操作系统协作） ##

在C中说过了，文件有文件的结尾标志，会被C识别为EOF字符，他的int数值是-1。并且**键盘也是可以模拟文件结尾符号的**，对于Windows的命令行（类DOS）是CRTL+Z+ENTER，这种组合按键会让操作系统检测到模拟文件尾，于是输入给程序，C++中完全一样。

如果使用文件作为程序的输入，也是很简单，就是利用重定向，在命令行输入下面这种代码，gofish是C++编译得到的EXE文件，fishtale是输入文件，里面存着输入数据，<是重定向运算符，和cout使用的插入运算符很像，都描绘了信息流动的方向

gofish < fishtale

### 示例3 用EOF结束输入 ###

#include <iostream>
    int main()
    { 
        using std::cin;
        using std::cout;
        using std::endl;
    
        char ch;
        int count = 0;
        cout << "Enter characters:\n";
        cin.get(ch);
        //检测到EOF后，cin把eofbit和failbit都设置为1
        //成员函数eof()可以查看eofbit是否为1，为1则返回true
        //如果eofbit或者failbit被设置为1，则成员函数fail()返回true，所以常用fail()
        while(cin.fail() == false)//等于false则没检测到EOF
        { 
            cout << ch;
            ++count;//这里和count++毫无区别
            cin.get(ch);
        }
        cout << endl << count << " characters read.\n";
    
        return 0;
    }

注意键盘模拟EOF必须在行首输入，如果前面有其他字符，就不会被检测到！！！！  
9个字符是因为有换行符！

Enter characters:
    a b     c
    a b     c
    f^Z
    f
    
    ^Z
    
    9 characters read.

### 每次读取一个字符，直到遇到EOF 的while循环基本设计（精，利用cin.get(char)的返回值） ###

由于遇到EOF才结束，所以不能直接用cin,否则空白符就结束了

最普通的版本

cin.get(ch);
    while(cin.fail() == false)//为false则没检测到EOF
    { 
    	//do sth with the character
    	cin.get(ch);
    }

小改, 把==false用非运算符替代，简洁些

cin.get(ch);
    while(!cin.fail())//为false则没检测到EOF
    { 
    	//do sth with the character
    	cin.get(ch);
    }

继续改，不用fail()函数，因为cin.get()方法自己有返回值，他的返回值是读取字符后的cin对象，并且istream类有一个方法，只要cin出现在需要bool值的地方，就会自动把cin转换为bool类型，所以如果成功读取，则cin的bool值是true，反之是false。所以根本不需要使用设置EOF标志的函数fail()和eof()，直接用cin.get()的返回值，反正遇到EOF肯定读取不到返回false。还能顺便把其他导致读取字符失败的错误也拦截到

cin.get(ch);
    while(cin)
    { 
    	//do sth with the character
    	cin.get(ch);
    }

继续修，上面的循环的初始条件和更新是一样的，实际上测试条件也和初始条件，更新条件一样,改成一个简洁得多的版本，又检查了文件尾，又检查了其他读取错误，还没用其他函数，直接利用cin.get()的返回值。

初始条件，测试条件，更新条件全部用一个cin.get(ch)表示。其中测试条件使用的是表达式的值，而初始条件和更新条件使用的是表达式的副作用，即给ch赋值

while(cin.get(ch))
    { 
    	//do sth with the character
    }

除了使用cin.get(char)外，还可以使用cin.get()，上面说了，它返回一个int值，是字符编码，如果**遇到EOF，则返回的是-1**

但是**cin.get(ch)在遇到EOF时，不会给ch赋任何字符。**

int ch;//不用char,因为还有eof
    ch = cin.get();
    while(ch != EOF)
    { 
    	//do sth with ch
    	ch = cin.get();
    }

和刚才同理。这里的三个表达式也可以合并到测试条件里

int ch;//不能用char！！因为还有eof
    while((ch = cin.get()) != EOF)//EOF在文件iostream中定义
    { 
    	//do sth with ch
    }

#### 示例 修改上一个示例 ####

可能我的编译器的实现没分signed和unsigned吧，我试了不用强制转换也没出错，不过还是养成习惯，**用cout.put()就用char强制转换**  
![在这里插入图片描述][20200303114030454.png]

#include <iostream>
    int main()
    { 
        using namespace std;
        int ch, count = 0;
    
        cout << "Enter characters:\n";
        while((ch = cin.get()) != EOF)//赋值表达式的值是左操作数的值
        { 
            ++count;
            cout.put(char(ch));//类似于C的预定义类函数宏putchar()
        }
        cout << count << " characters read.\n";
        return 0;
    }

注意其中while((ch = cin.get()) != EOF)一定要加括号，不加的话：while(ch = cin.get() != EOF)，由于!=的优先级高于赋值运算符，程序会首先比较EOF和cin.get()的返回值，然后把true或者false赋给ch,由于ch是int类型，所以ch只能获取到0或者1

Enter characters:
    erefd./
    erefd./
    ^Z
    8 characters read.

# 嵌套循环非常适合处理二维数组 #

循环用来处理一维数组非常好使，嵌套循环处理二维数组也很好

语言都不提供专门的二维数组类型，直接把数组的元素定义为数组就好了

## 示例1 像表格一样输出二维数组 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]

#include <iostream>
    int main()
    { 
        using namespace std;
        const int row = 4;
        const int col = 5;
        int ar[row][col] = { };
        int i, j;
    
        for (i = 0; i < row; ++i)
        { 
            for (j = 0; j < col; ++j)
            { 
                cout << ar[i][j] << '\t';
            }
            cout << endl;
        }
        return 0;
    }

但是内存里数组是线性存储的哈  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 2]

## 示例2 cout遇到char指针会打印字符串 ##

#include <iostream>
    const int Cities = 5;
    const int Years = 4;
    int main()
    { 
        using namespace std;
    
        //用字符指针数组实现字符串数组，字符串长度没有死的限制
        //const限定符使得这个字符串数组不可修改
        const char * cities[Cities] =
        { 
            "Gribble City",
            "Gribbletown",
            "New Gribble",
            "San Gribble",
            "Gribble Vista"
        };
    
        int maxtemps[Years][Cities] =
        { 
            { 89, 100, 23, 56, 67},
            { 45, 23, 78, 89, 90},
            { 23, 56, 26, 59, 20},
            { 98, 96, 95, 90, 76}
        };
    
        cout << "Maximum temperatures for 2008-2011:\n\n";
        int city, year;
        for (city = 0; city < Cities; ++city)
        { 
            cout << cities[city] << ":\t";//cout遇到char指针会打印字符串
            for (year = 0; year < Years; ++year)
            { 
                cout << maxtemps[year][city] << '\t';
            }
            cout << endl;
        }
        return 0;
    }

Maximum temperatures for 2008-2011:
    
    Gribble City:   89      45      23      98
    Gribbletown:    100     23      56      96
    New Gribble:    23      78      26      95
    San Gribble:    56      89      59      90
    Gribble Vista:  67      90      20      76

如果用char数组的数组实现字符串数组，则限制了字符串长度

//字符串最长24个字符
    const char cities[Cities][25] =
        { 
            "Gribble City",
            "Gribbletown",
            "New Gribble",
            "San Gribble",
            "Gribble Vista"
        };

# 练习 #

![在这里插入图片描述][20200303124023369.png]  
打印  
6  
8

6
    8

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 3]  
第一个x=024,八进制数，换算为十进制是20，因为逗号表达式的值是第二项的值

第二个y=1，因为赋值运算符优先级高于逗号运算符，这相当于逗号运算符把y=1和024两个表达式合并了

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 4]

#include <iostream>
    #include <cstring>
    int main()
    { 
        using namespace std;
        cout << "Enter a word:\n";
        char word[20];//相当于一个输入缓冲
        cin >> word;
        int count = 0;
    
        while(strcmp(word, "done"))
        { 
            ++count;
            cin >> word;
        }
        cout << ++count << " words entered to find the \"done\"!\n";
        return 0;
    }

Enter a word:
    her
    doea
    does
    do
    did
    done
    6 words entered to find the "done"!

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 5]

#include <iostream>
    int main()
    { 
        using namespace std;
        cout << "Enter the line number:\n";
        int line;
        cin >> line;
        int row, col;
    
        for (row = 0; row < line; ++row)
        { 
            for (col = 0; col < line; ++col)
            { 
                if(col < line - row - 1)
                { 
                    cout << '.';
                }
                else
                { 
                    cout << '*';
                }
            }
            cout << endl;
        }
        return 0;
    }

Enter the line number:
    5
    ....*
    ...**
    ..***
    .****
    *****
    
    Enter the line number:
    7
    ......*
    .....**
    ....***
    ...****
    ..*****
    .******
    *******

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200303114829452.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200303114030454.png]: https://img-blog.csdnimg.cn/20200303114030454.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200303121317580.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200303121344244.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200303124023369.png]: https://img-blog.csdnimg.cn/20200303124023369.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2020030312441631.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200303124755548.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200303124656836.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70