C++ Primer 学习笔记_19_语句 --if/switch/while/for语句



语句

--if/switch/while/for语句

1、空语句：用于语法上需要一个语句，而逻辑上并不需要的位置，此时需要一个空语句，如：

[cpp] view plaincopyprint?

1. while (cin >> s && s != sought)  
2.     ;   //空语句  

    while (cin >> s && s != sought)        ;//空语句

无关的空语句并不是总是无害的！

[cpp] view plaincopyprint?

1. //此处的空语句使得循环无法正常结束！  
2.    while (iter != ivec.end());    
3.    ++iter;  

//此处的空语句使得循环无法正常结束！    while (iter != ivec.end());    ++iter;

2、复合语句是用一对花括号将几条语句扩起来，使其在语法上成为单个语句。

3、语句作用域

    在语句的控制结构中定义的变量，仅在定义他们的块语句结束前有效。

    对于控制语句中定义的变量，限制其作用域的一个好处是：这些变量名可以重复使用而不必担心他们的当前值在每一次使用时是否正确。对于作用域外的变量，是不可能用到其在作用域内的残留值的！

4、if语句

    如果在条件表达式中定义了变量，那么变量必须初始化。而且：将已初始化的变量值转换成为bool类型值后，该bool类型值决定条件是否成立！

[cpp] view plaincopyprint?

1. if (int ival = compute_value())  
2. {  
3.     //...  
4. }  

if (int ival = compute_value()){//...}

【建议：】在if后面使用花括号，这样可以避免日后修改代码时产生混乱和错误。因此，无论if（或者while，for，dowhile）后面是简单语句，例如：赋值或输出语句，还是其他任意类型的语句，使用花括号都是一个比较好的做法！

5、switch语句

    switch语句提供了一种更方便的的方法来实现深层次嵌套的if/else逻辑

[cpp] view plaincopyprint?

1. char ch;  
2. int aCnt = 0,eCnt = 0,iCnt = 0,  
3.     oCnt = 0,uCnt = 0;  
4.   
5. while (cin >> ch)  
6. {  
7.     switch (ch)  
8.     {  
9.     case 'a':  
10.         ++aCnt; //不要忘记后面的break标号！  
11.         break;  
12.     case 'e':  
13.         ++eCnt;  
14.         break;  
15.     case 'i':  
16.         ++iCnt;  
17.         break;  
18.     case 'o':  
19.         ++oCnt;  
20.         break;  
21.     case 'u':  
22.         ++uCnt;  
23.         break;  
24.     }  
25. }  
26. cout << "a: " << aCnt << '\n'  
27.      << "e: " << eCnt << '\n'  
28.      << "i: " << iCnt << '\n'  
29.      << "o: " << oCnt << '\n'  
30.      << "u: " << uCnt << endl;  

    char ch;    int aCnt = 0,eCnt = 0,iCnt = 0,        oCnt = 0,uCnt = 0;    while (cin >> ch)    {        switch (ch)        {        case 'a':            ++aCnt;//不要忘记后面的break标号！            break;        case 'e':            ++eCnt;            break;        case 'i':            ++iCnt;            break;        case 'o':            ++oCnt;            break;        case 'u':            ++uCnt;            break;        }    }    cout << "a: " << aCnt << '\n'         << "e: " << eCnt << '\n'         << "i: " << iCnt << '\n'         << "o: " << oCnt << '\n'         << "u: " << uCnt << endl;

如果表达式与其中一个case标号的值匹配，则程序将从该标号后面的第一个语句开始依次执行各个语句，知道switch结束或者遇到break语句为止！

6、default标号

[cpp] view plaincopyprint?

1.   char ch;  
2.   int vowelCnt = 0;  
3.   int otherCnt = 0;  
4.   
5.   while (cin >> ch)  
6.   {  
7.       switch (ch)  
8.       {  
9.       case 'a':  
10.       case 'e':  
11.       case 'i':  
12.       case 'o':  
13.       case 'u':  
14.           ++vowelCnt;  
15.           break;  
16. default:  
17.     ++otherCnt;  
18.     break;  
19.       }  
20.   }  
21.   cout << "vowel: " << vowelCnt << endl;  
22.   cout << "other: " << otherCnt << endl;  

    char ch;    int vowelCnt = 0;    int otherCnt = 0;    while (cin >> ch)    {        switch (ch)        {        case 'a':        case 'e':        case 'i':        case 'o':        case 'u':            ++vowelCnt;            break;default:++otherCnt;break;        }    }    cout << "vowel: " << vowelCnt << endl;    cout << "other: " << otherCnt << endl;

哪怕没有语句要在default标号下执行，定义default标号仍然是有用的。定义default标号是为了告诉读者，表明这种情况已经考虑到了，只是没什么要执行的！

7、switch表达式与case标号

switch求解的表达式可以非常复杂。特别是，该表达式还可以定义和初始化一个变量：

[cpp] view plaincopyprint?

1. switch(int ival = get_reponse())  
2. {  
3.     //...  
4. }  

switch(int ival = get_reponse()){//...}

而case标号必须是整型常量表达式

[cpp] view plaincopyprint?

1. case 3.14:  //error  
2.     //...  
3.     break;  
4. case ival:  //error  
5.     //..  
6.     break;  

case 3.14://error//...break;case ival://error//..break;

且只能在最后一个case标号或default标号下才可以定义变量：

[cpp] view plaincopyprint?

1. case 'a':  
2.     string name = "xiaofang";   //error  
3.     break;  
4. case 'b':  
5.     //..  
6.     break;  

    case 'a':        string name = "xiaofang";//error        break;    case 'b':        //..        break;

如果必须为某个特殊的case定义变量，则需引入块语句，在该块语句中定义变量：

[cpp] view plaincopyprint?

1. case 'a':  
2.     {  
3.         string name = "xiaofang";   //ok  
4.     }  
5.     break;  
6. case 'b':  
7.     //..  
8.     break;  

    case 'a':        {        string name = "xiaofang";//ok        }        break;    case 'b':        //..        break;

8、while语句

    在while中，循环条件可以是一个表达式，也可以是一个提供初始化的变量定义：

[cpp] view plaincopyprint?

1. while (int loc = search(name))  
2. {  
3.     //...  
4. }  

while (int loc = search(name)){//...}

而且，在循环条件中定义的变量在每次循环里都要经历创建和撤销的过程。

[cpp] view plaincopyprint?

1. //P179 习题6.12  
2. int main()  
3. {  
4.     int maxCnt = 1,curCnt = 0;  
5.     string now,last,ans;  
6.   
7.     while (cin >> now)  
8.     {  
9.         if (now == last)  
10.         {  
11.             ++curCnt;  
12.         }  
13.         else  
14.         {  
15.             if (curCnt > maxCnt)  
16.             {  
17.                 maxCnt = curCnt;  
18.                 ans = last;  
19.             }  
20.   
21.             curCnt = 1;  
22.         }  
23.         last = now;  
24.     }  
25.     if (curCnt != 1)  
26.     {  
27.         cout << ans << ": " << maxCnt << endl;  
28.     }  
29.     else  
30.     {  
31.         cout << "There is no repeated word!" << endl;  
32.     }  
33. }  

//P179 习题6.12int main(){    int maxCnt = 1,curCnt = 0;    string now,last,ans;    while (cin >> now)    {        if (now == last)        {            ++curCnt;        }        else        {            if (curCnt > maxCnt)            {                maxCnt = curCnt;                ans = last;            }            curCnt = 1;        }        last = now;    }    if (curCnt != 1)    {        cout << ans << ": " << maxCnt << endl;    }else{cout << "There is no repeated word!" << endl;}}

9、for循环与while的对比

while循环特别擅长在某个条件保持为真时反复的执行，而一般认为for循环是一种按步骤执行的循环！

[cpp] view plaincopyprint?

1. //P181 习题6.16  
2. int main()  
3. {  
4.     vector<int> ivec1,ivec2;  
5.     int value;  
6.   
7.     while (cin >> value && value != 32767)  
8.     {  
9.         ivec1.push_back(value);  
10.     }  
11.     while (cin >> value && value != 32767)  
12.     {  
13.         ivec2.push_back(value);  
14.     }  
15.     unsigned int n = (ivec1.size() < ivec2.size() ? ivec1.size() : ivec2.size());  
16.   
17.     for (vector<int>::size_type i = 0; i != n ; ++i)  
18.     {  
19.         if (ivec1[i] != ivec2[i])  
20.         {  
21.             cout << "false" << endl;  
22.             return 0;  
23.         }  
24.     }  
25.     cout << "true" << endl;  
26. }  

//P181 习题6.16int main(){vector<int> ivec1,ivec2;int value;while (cin >> value && value != 32767){ivec1.push_back(value);}while (cin >> value && value != 32767){ivec2.push_back(value);}unsigned int n = (ivec1.size() < ivec2.size() ? ivec1.size() : ivec2.size());for (vector<int>::size_type i = 0; i != n ; ++i){if (ivec1[i] != ivec2[i]){cout << "false" << endl;return 0;}}cout << "true" << endl;}

10、dowhile语句

    1）与while语句不同，dowhile保证循环体至少执行一次，而且dowhile语句是以;分号结束

    2）如果把变量定义在了do内部，那么该变量的作用域就被限制在while前的花括号之前了

[cpp] view plaincopyprint?

1. do  
2. {  
3.     int ival = 1;  
4. }  
5. while (ival == 1);//error  

    do    {        int ival = 1;    }    while (ival == 1);//error

[cpp] view plaincopyprint?

1. //P183 习题6.18  
2. int main()  
3. {  
4.     string str1,str2;  
5.     do  
6.     {  
7.         cout << "Please input two strings:" << endl;  
8.         cin >> str1 >> str2;  
9.         if (str1 > str2)  
10.         {  
11.             cout << str1 << " is bigger!" << endl;  
12.         }  
13.         else  
14.         {  
15.             cout << str2 << " is bigger!" << endl;  
16.         }  
17.         cout << "continue?" << endl;  
18.         cin >> str1;  
19.     }  
20.     while (str1 != "no" && str1 != "No" && str1 != "NO");  
21. }