#include <stdio.h>
        #include <ctype.h>

        int main(void)
        {
            int ch;  /* 注意，ch 一定要定义为 int 类型。参考这里 */
            unsigned apple     = 0,
                     egg       = 0,
                     icecream  = 0,
                     orange    = 0,
                     umbrella  = 0,
                     other     = 0;

            printf("Please type in a sentence:\n");
            while ( (ch = getchar()) != '\n' )
            {
                switch ( tolower(ch) )  /* tolower 返回 ch 对应的小写字母的值 */
                {
                    case 'a' :
                        ++apple;
                        break;
                    case 'e' :
                        ++egg;
                        break;
                    case 'i' :
                        ++icecream;
                        break;
                    case 'o' :
                        ++orange;
                        break;
                    case 'u' :
                        ++umbrella;
                        break;
                    default :
                        ++other;
                        break;  /* 此行不写也没啥关系，习惯上还是写上的好 */
                }
            }

            printf("a    : %u\n"
                   "e    : %u\n"
                   "i    : %u\n"
                   "o    : %u\n"
                   "u    : %u\n"
                   "other: %u\n",
                   apple,
                   egg,
                   icecream,
                   orange,
                   umbrella,
                   other);

            return 0;
        }

    在往下看之前，请先想一下该程序是做什么用的，然后编译运行，看看结果和你想的是否一致。如果一致，那可以说你已经基本上学会了 switch 语句。以下是该程序运行的结果：

        Please type in a sentence:
        Welcome to http://stdcpp.cn. Please enjoy yourself here.
        a    : 1
        e    : 8
        i    : 0
        o    : 4
        u    : 1
        other: 42

    下面我们讲解一下 switch 语句的用法。switch 语句的结构如下所示：

        switch (整型表达式)
        {
            case 整型常量1:
                一系列语句    // 可有可无
            case 整型常量2:
                一系列语句    // 可有可无
            case 整型常量3:
                一系列语句    // 可有可无
            // ... ...
            default :         // 可有可无
                一系列语句    // 可有可无

        }

其中，“整型表达式”指的是其值为整数类型（包括 char）的表达式；case 标签中的“整型常量”必须是整数类型（当然也包括 char）的常量或者常量表达式（只包含整型常量的表达式）。case 标签中不能使用变量！C99 标准规定，一个 switch 里至少可以用 1023 个 case 标签，而且不包括 switch 语句中的嵌套 switch 语句的 case 标签。原文如下：

    下面，我们通过讲解上例的执行过程来学习 switch 语句。首先，getchar 读取用户输入的一个字符，然后该字符被赋值给 ch，接着判断 ch 是否为 '\n'（也就是判断是否已经读完一行），如果 ch 为 '\n'，则退出循环。以我们的输入为例：

    你可能会觉得很奇怪——为什么每个标签后都要写上 break 语句呢，它在这里是干什么用的？其实，它在这里的作用是跳出 switch 语句，转而执行 switch 语句后面的语句。如下图所示（假设 number 的值为 2）：

如果不写 break 语句，则从匹配的标签开始，直到 switch 语句结束前的语句都会被执行。例如，如果把上例中的 break 语句都去掉，重新编译后，在运行时输入 I，则会得到如下结果：

        Please type in a sentence:
        I
        a    : 0
        e    : 0
        i    : 1
        o    : 1
        u    : 1
        other: 1

由此可见，“case 'i' :”后面，switch 语句结束前的所有语句都被执行了一遍。因此，千万别忘了写上 break 语句，它非常重要！

    再回到我们前面的例子，while 循环第二次读到 'e'，和“case 'e' :”匹配，则执行

    本例使用 tolower 函数（需包含头文件 ctype.h）是为了能统计大写的元音字母。当然，不用 tolower 也能达到统计大写元音字母的目的，只要为对应的大写字母添加一个标签即可。例如：

        switch ( ch )
        {
            case 'a' :
            case 'A' :
                ++apple;
                break;
            case 'e' :
            case 'E' :
                ++egg;
                break;
        ... ...

    break 语句既能用于跳出循环，也能用于跳出 switch，但 continue 语句只能作用于循环。当 switch 语句位于循环里时：

• switch 语句中的 break 语句只跳出 switch 语句，而不会更进一步跳出包含该 switch 语句的循环。
  
• switch 语句中的 continue 语句将致使程序跳过循环中余下的语句（当然也包括 switch 语句中余下的语句），转而判断循环条件是否仍然成立，然后选择是否再次进入循环体。

参考资料：C Primer 5th Edition
          C99 标准 - 6.8.4.2 The switch statement

         #include <stdio.h>

         int main( void )            /* 一个简单的程序 */
         {
             int num;                  /* 声明一个名叫 num 的变量 */
             num = 1;                  /* 将 1 赋值给 num         */

             printf( "This is a simple C program.\n" ); /* 调用 printf 函数 */
             printf( "My favorite number is %d because it is first.\n", num );

             return 0;
         }

     在对这个程序进行详细说明之前，我想先请您用编译器把它编译成可执行文件，并且运行，看看运行结果和您的猜想是否一致。如果不懂如何进行编译，请参考以下文章：

    Dev-C++安装&使用教程
    Dev-C++ 下载

     下面，我将分两步对这个程序进行详细的讲解。第一步是概要说明，也就是对程序中每一行代码的含义作简单讲解，以帮助您对这个程序有一个大致的理解。第二步是详细说明，也就是程序中的每一行代码进行详细的讲解，以加深您的理解。

    一、概要说明

                 #include <stdio.h>    <-   把另外一个文件包含进来
            这行代码命令编译器把头文件（.h 文件）stdio.h 中的内容包含到我们的
       程序中。stdio.h是C语言的标准头文件之一，提供对键盘输入和显示输出等的
       支持。要使用 printf 函数，就应该包含这个头文件。顺带一提，stdio 代表
       standard input/output，也就是标准输入输出的意思。

                 int main(void)    <-   函数头
             C 程序由一个或多个函数组成。我们的这个程序只有一个函数：main 函数。
       圆括号() 表明 main 是一个函数；int 表明 main 函数返回一个整数；void 表明
       main 函数不接受任何参数。在此，请您紧记，int main(void) 是 ISO/ANSI C
      标准中定义的 main 函数定义方法之一。

                 /* a simple program */    <-   注释
             /* 和 */ 用于对程序进行注释说明，帮助读者更快更好地理解程序。编译器
       会忽略 /* 和 */ 之间的内容（包括 /* 和 */），不会对它们进行编译。

                 {        <-   函数体的开端
             这个开大括弧 { 标志着函数体开始。函数体以闭大括弧 } 结束。在 { 和 }
       之间的语句都属于这个函数。

                 int num;     <-   声明变量 num
             这个语句表明我们声明了一个名叫 num 的变量。int 表明这个变量为
       整型变量。

                 num = 1;     <-   赋值语句
             这个语句将 1 赋值给变量 num 。执行这个语句后，num 的值等于 1 。

                   printf( "This is a simple C program.\n" );    <-   函数调用语句
             printf 函数是 C 语言标准函数库里的函数。这个语句调用 printf 函数在
        屏幕上显示“This is a simple C program.”，并且换行。\n 是换行符，它提示
        printf 开始新的一行，也就是将光标移动到下一行的开端。如果上面的语句中没有
        \n ，那就不会换行，而且光标会紧跟在“This is a simple program.”后面。

                   printf( "My favorite number is %d because it is first.\n", num );
             %d 告诉 printf 用num的值替换掉 %d ，并且以整数形式显示num的值。
        因为 num 的值为 1 ，所以这个语句在屏幕上显示“My favorite number is 1
       because it is first.”，并且换行。

                 return 0;    <-   返回语句
             C 程序应该返回一个数值给它的调用者。0 代表程序无误退出；而其它数字的含义
        则由系统决定。通常，非零（如 -1）代表程序运行中遇到某种错误而退出。

                 }     <-   函数体结束
          函数体以闭大括弧 } 结束。

    二、详细说明

         现在，让我们进一步来了解每一行代码的含义。下面的内容很基础，也很重要，
     必须认真弄懂，牢牢掌握。

          1.#include预处理指令和头文件

              在编译器对我们写的源程序进行编译之前，预处理器会对我们的写的源代码
       进行必要的处理，称为预处理。#include 就是一个预处理指令，它命令预处理器
        进行的预处理是：把特定的头文件包含到我们的源代码里。
            #include <stdio.h>的作用是将头文件 stdio.h 里的内容包含进我们的程序，
        产生的结果是将 stdio.h 里的内容一字不漏地插入 #include <stdio.h>出现的
        地方，并且删除 #include <stdio.h>。换句话说，就是用 stdio.h 里的内容替换
        #include <stdio.h>。这个过程是在预处理阶段完成的。C 语言的这种包含文件的
        机制为多个程序共享相同信息提供了极大的方便。
            stdio.h 是 C 语言标准中定义了的头文件，它包含着输入输出函数的信息。
        所有 C 编译器都应该有这个头文件，这是 ANSI/ISO C 标准中规定的。当然，
        ANSI/ISO C 规定的编译器必须提供的头文件可不止这么一个。标准还规定了许多
        别的头文件，那些我们会在以后慢慢学到。
            有些程序需要包含 stdio.h ，而有些不需要。如果上面这个例子中没有使用
        printf 函数，那就不需要包含 stdio.h 。
            头文件中包含着编译器进行编译时所需的信息。头文件中可能指明了函数名和
        函数调用方法，但是这些函数的实现代码并不在头文件中，而是在预先编译好了的
        库文件里。
            链接器负责在库文件中寻找我们的程序所需的代码，并且把那些代码和我们写的
        程序进行链接，从而将我的写的程序链接成可执行文件。一句话，头文件用于指导
        编译器正确地将我们写的源程序编译成可执行文件。

          2.main 函数

               在 C 语言中，main 函数是主函数。每个 C 程序都必须有且只能有一个
       main 函数（主函数）！C 程序从 main 函数开始执行，并且在 main 函数中结束。
            int是 main 函数的返回值类型，它表明 main 函数应该返回一个整数给程序的
        调用者（如操作系统）。
            如果您想了解更多关于 main 函数的东西，请点击下面的链接：
              C/C++ 误区一：void main

          3. 注释

                    /* a simple program */
              /* */ 之间的内容都是注释。对程序进行适当的注释可以帮助读者（包括您自己）
          更快更好地理解您写的代码。注释可以在源程序中的任何地方书写。/* 和 */ 之间的
          任何内容（包括 /* 和 */）都会被编译器忽略掉。注意：/ 和 * 必须紧挨在一起，
          它们之间不能有空格。
                     /* 我是注释 */
                     /*我是
                       跨行注释*/
                     /*
                       我也是注释
                     */
              以上的注释都是合法的；但下面的注释是非法的，因为没写注释结束标记 */。
                     /* 非法，没有注释结束标记
              下面这个注释可能会出乎你的意料：
                     /* 我是注释开始标记
                     /* 哦哦，我不是注释开始标记
                        我是注释结束标记，我和第一个 /* 匹配，而不是和第二个 /* 匹配。*/
              上面这个注释中，注释结束标记 */ 和第一个 /* 匹配，它们之间的内容
          都被视为注释。

              C99 中增加了另外一种注释方式，这种注释方式使用 // 作为注释符，和 //
          处于同一行，并且在 // 右边的内容都被当作注释。/ 和 / 之间不能有空格。
                     // 我是注释
                     int rigue;      //注释放在这里也是合法的
              上面的注释在 C99 中是合法的，但是在 C89 中是非法的。也就是说，老旧的
          编译器可能不支持 // 注释符。VC6 支持 //，TC2 不支持。
               
          4. 大括号与函数体

               C 语言中，所有函数都以大括弧（{ }）作为界定符。函数体从开大括弧 {
        开始，以闭大括弧 } 结束。在后续教程中，我会对函数进行更详细的讲解。

          5. int num;

               这个语句声明了变量 num 。这一行末尾的分号（;）表明这一行
        是一个语句。; 是语句的一部分，单独一个 ; 也是一个合法的 C 语句。
             int 是 C 语言中的一个关键字，它代表 C 语言里的一种基本数据类型：整型。
        关键字是语言的保留字，不能用作其它用途。例如：我们不能关键字来做变量名或者
        函数名。
             标识符是指我们为变量或函数等取的名字。在这个语句中，num 就是标识符。
             C 语言中，所有变量在使用前都必须声明。C89 中，变量的声明必须位于
        函数体或者程序块的开端。例如：
                  int main( void ) /* C89 */
                  { /* 函数体开始 */
                      int doors;
                      int dogs;
                      doors = 5;
                      dogs = 3;
                      { /* 程序块开始 */
                           int dig;
                           int dug;
                           dig = 6;
                           dug = 8;
                      } /* 程序块结束 */

                      return 0;
                  } /* 函数体结束 */
             而在 C99 中，声明可以位于函数体或者程序块的任何地方。但是，变量仍然
        需要在声明之后才可使用。例如：
                  int main( void ) /* C99 */
                  { /* 函数体开始 */
                      int doors;
                      doors = 5;
                      { /* 程序块开始 */
                          int dig;
                          dig = 6;
                          int dug;
                          dug = 8;
                      } /* 程序块结束 */
                      int dogs;
                      dogs = 3;

                      return 0;
                  } /* 函数体结束 */
             上面的程序在 C99 中是合法的，但是在 C89 中却是非法的。当前支持C99 的
        编译器不多，所以上面的代码您的编译器很有可能编译不了。故而，为了使我们的
        代码具有良好的可移植性，我们应该尽可能少用，甚至不用 C99 中的新特性。

        6. 赋值

                  num = 1;
             赋值是 C 语言中的一种基本操作。上面的语句是一个赋值语句，它的含义
        是：将 1 赋值给变量 num 。赋值操作完成后，num 的值等于 1 。

        7.printf 函数

             printf( "This is a simple C program.\n" );
             printf( "My favorite number is %d because it is first.\n", num );
            这两行代码都调用了 printf 函数。printf 是一个标准 C 函数，也就是说，
        它是 C 语言标准函数库里定义了的函数。圆括号 () 表明 printf 是一个函数，
        圆括号里的内容会被传递给 printf 函数。例如，上面第一行代码把“This is a
        simple C program.\n”（不包括双引号）传递给 printf 函数，然后由 printf
        函数把这些信息显示于显示器。\n 是换行符，它提示 printf 开始新的一行。
        正因为 \n 是换行符，所以 \n 不会显示出来，而是进行了换行。如果上面的语句中
        没有 \n ，那就不会换行。
            上面代码第二行中的 %d 告诉 printf 用 num 的值替换掉 %d ，并且以
        整数形式显示 num 的值。
             %d 被称为占位符，它告诉 printf 应该在什么地方显示 num 的值。% 用于
        提醒 printf 在此处显示一个变量的值（本例中是 num 的值）；d 告诉 printf 以
        十进制整数的形式显示 num 的值。

        8.return（返回）语句

                   return 0;
             这个 return 语句是我们程序中的最后一个语句。int main( void ) 中的 int
        表示 main 函数应该返回一个整数，所以我们要使用 return 语句来返回一个整数。
             如果您想了解更多关于返回值的东西，请点击下面链接，查看文章的第四点。

                   C/C++ 误区一：void main

           
    上面所说的某些内容您暂时可能还不太理解，但是不用害怕，牢牢地把它们记住，然后继续往下学吧！随着学习的深入，就会逐渐搞明白。现阶段只要有这个概念就足够了。

参考资料：C Primer Plus, 5th Edtion By Stephen Prata

本文版权归 蚂蚁的 C/C++ 标准编程 以及 作者 antigloss 共同所有，转载请注明原作者和出处。谢谢。