C#程序结构
 
 
 
一个 C# 程序主要包括以下部分：这里以控制台程序为实例
 
 
命名空间声明（Namespace declaration）
一个 class
Class 方法
Class 属性
一个 Main 方法
语句（Statements）& 表达式（Expressions）
注释
 
C# 文件的后缀为 .cs。
 
 
 
具体如下图
 
 

 当上面的代码被编译和执行时，它会产生下列结果：在控制台输出一个Hello World
 
 
 
 
让我们看一下上面程序的各个部分：
 
 
程序的第一行 using System; - using 关键字用于在程序中包含 System 命名空间。 一个程序一般有多个 using 语句。
 下一行是 namespace 声明。一个 namespace 里包含了一系列的类。HelloWorldApplication 命名空间包含了类 HelloWorld。
 下一行是 class 声明。类 HelloWorld 包含了程序使用的数据和方法声明。类一般包含多个方法。方法定义了类的行为。在这里，HelloWorld 类只有一个 Main 方法。
 下一行定义了 Main 方法，是所有 C# 程序的 入口点。Main 方法说明当执行时 类将做什么动作。
 下一行 /…/ 将会被编译器忽略，且它会在程序中添加额外的 注释。
 Main 方法通过语句 Console.WriteLine(“Hello World”); 指定了它的行为。
 WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法。该语句会在屏幕上显示消息 “Hello World”。
 
最后一行 Console.ReadKey(); 是针对 VS.NET 用户的。这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。
 
 
 
以下几点值得注意：
 
 
C# 是大小写敏感的。
 所有的语句和表达式必须以分号（;）结尾。
 程序的执行从 Main 方法开始。
 与 Java 不同的是，文件名可以不同于类的名称。
 
编译 & 执行 C# 程序
 
使用 Visual Studio.Net 编译和执行 C# 程序，可以按照步骤进行：
 
 
启动 Visual Studio。
 
 
 
在菜单栏上，选择 File -> New -> Project。
 
 
 
从模板中选择 Visual C#，然后选择 Windows。
 
 
 
选择 Console Application。
 
 
 
为您的项目制定一个名称，然后点击 OK 按钮。
 
 
 
新项目会出现在解决方案资源管理器（Solution Explorer）中。
 
 
 
在代码编辑器（Code Editor）中编写代码。
 
 
 
点击 Run 按钮或者按下 F5 键来运行程序。会出现一个命令提示符窗口（Command Prompt window），显示 Hello World。
 
 
 
====================================================================================================
 当然我们也可以使用命令行代替 Visual Studio IDE 来编译 C# 程序：
 
 
 
打开一个文本编辑器，添加上面提到的代码。
 
 
 
 
 
保存文件为 helloworld.cs。
 
 
 
打开命令提示符工具，定位到文件所保存的目录。
 
键入 csc helloworld.cs 并按下 enter 键来编译代码。
 如果代码没有错误，命令提示符会进入下一行，并生成 helloworld.exe 可执行文件。
 接下来，键入 helloworld 来执行程序。
 您将看到 “Hello World” 打印在屏幕上。
 
 
 
ps:
 
 
若提示无法识别 csc 命令，需配置环境变量（Window10)
 找到桌面上的“计算机”图标，右键单击，并在弹出的菜单中点击 “属性” --“高级系统设置”–“环境变量”–“系统变量”，找到变量 Path， 添加一个路径 ;C:\Windows\Microsoft.NET\Framework\v2.0.50727\（注意，多个路径使用分号(;)隔开，Windows其他版本追加在后面即可）。
 

程序编译的过程中就是将用户的文本形式的源代码(c/c++)转化成计算机可以直接执行的机器代码的过程。主要经过这么几个过程： 
 1、编译，由编译器将c源代码（.cpp）转变成汇编代码（.s） 
 2、汇编，由汇编器将汇编代码（.s）转变成目标代码（.o） 
 3、链接，由链接器将代码在执行过程用到的其他目标代码和库文件链接成为一个可执行程序也就是目标程序。
 
1、编译
 
编译的过程就是将源代码文件以字符流的形式进行处理，进行词法和语法的分析，然后通过汇编器将源代码指令转变成汇编指令，编译的过程包括两个大部分：预处理
 
而编译预处理主要对文件中的四种情况处理：宏定义、#include文件包含、条件编译、特殊符号
 
特殊符号是指：例如在源程序中出现的LINE标识将被解释为当前行号（十进制数），FILE则被解释为当前被编译的C源程序的名称。预编译程序对于在源程序中出现的这些串将用合适的值进行替换。
 
总的来说，预编译程序所完成的基本上是对源程序的“替代”工作。经过此种替代，生成一个没有宏定义、没有条件编译指令、没有特殊符号的输出文件。这个文件的含义同没有经过预处理的源文件是相同的，但内容有所不同。（经过预处理的输出文件中只有变量和c语言的关键字） 这一步将上一部的输出文件进行编译和优化。编译程序所要作得工作就是通过词法分析和语法分析，在确认所有的指令都符合语法规则之后，将其翻译成等价的中间代码表示或汇编代码。
 
优化处理是编译系统中一项比较艰深的技术。它涉及到的问题不仅同编译技术本身有关，而且同机器的硬件环境也有很大的关系。优化一部分是对中间代码的优化。这种优化不依赖于具体的计算机。另一种优化则主要针对目标代码的生成而进行的。
 
对于前一种优化，主要的工作是删除公共表达式、循环优化（代码外提、强度削弱、变换循环控制条件、已知量的合并等）、复写传播，以及无用赋值的删除，等等。
 
后一种类型的优化同机器的硬件结构密切相关，最主要的是考虑是如何充分利用机器的各个硬件寄存器存放有关变量的值，以减少对于内存的访问次数。另外，如何根据机器硬件执行指令的特点（如流水线、RISC、CISC、VLIW等）而对指令进行一些调整使目标代码比较短，执行的效率比较高，也是一个重要的研究课题。
 
经过优化得到的汇编代码必须经过汇编程序的汇编转换成相应的机器指令，方可能被机器执行。
 
2、汇编
 
汇编过程实际上指把汇编语言代码翻译成目标机器指令的过程。对于被翻译系统处理的每一个C语言源程序，都将最终经过这一处理而得到相应的目标文件。目标文件中所存放的也就是与源程序等效的目标的机器语言代码。
 
目标文件由段组成。通常一个目标文件中至少有两个段：
 
1) 代码段：该段中所包含的主要是程序的指令。该段一般是可读和可执行的，但一般却不可写。
 
2) 数据段：主要存放程序中要用到的各种全局变量或静态的数据。一般数据段都是可读，可写，可执行的。
 
UNIX环境下主要有三种类型的目标文件：
 
1) 可重定位文件
 
其中包含有适合于其它目标文件链接来创建一个可执行的或者共享的目标文件的代码和数据。
 
2) 共享的目标文件
 
这种文件存放了适合于在两种上下文里链接的代码和数据。
 
第一种是链接程序可把它与其它可重定位文件及共享的目标文件一起处理来创建另一个目标文件；
 
第二种是动态链接程序将它与另一个可执行文件及其它的共享目标文件结合到一起，创建一个进程映象。
 
3) 可执行文件
 
它包含了一个可以被操作系统创建一个进程来执行之的文件。
 
汇编程序生成的实际上是第一种类型的目标文件。对于后两种还需要其他的一些处理方能得到，这个就是链接程序的工作了。
 
 
 
3、链接
 
由汇编程序生成的目标文件并不能立即就被执行，其中可能还有许多没有解决的问题。
 
例如，某个源文件中的函数可能引用了另一个源文件中定义的某个符号（如变量或者函数调用等）；在程序中可能调用了某个库文件中的函数，等等。所有的这些问题，都需要经链接程序的处理方能得以解决。
 
链接程序的主要工作就是将有关的目标文件彼此相连接，也即将在一个文件中引用的符号同该符号在另外一个文件中的定义连接起来，使得所有的这些目标文件成为一个能够被操作系统装入执行的统一整体。
 
根据开发人员指定的同库函数的链接方式的不同，链接处理可分为两种：
 
静态链接
 
在这种链接方式下，函数的代码将从其所在的静态链接库中被拷贝到最终的可执行程序中。这样该程序在被执行时这些代码将被装入到该进程的虚拟地址空间中。静态链接库实际上是一个目标文件的集合，其中的每个文件含有库中的一个或者一组相关函数的代码。
 
动态链接
 
在此种方式下，函数的代码被放到称作是动态链接库或共享对象的某个目标文件中。链接程序此时所作的只是在最终的可执行程序中记录下共享对象的名字以及其它少量的登记信息。在此可执行文件被执行时，动态链接库的全部内容将被映射到运行时相应进程的虚地址空间。动态链接程序将根据可执行程序中记录的信息找到相应的函数代码。
 
对于可执行文件中的函数调用，可分别采用动态链接或静态链接的方法。使用动态链接能够使最终的可执行文件比较短小，并且当共享对象被多个进程使用时能节约一些内存，因为在内存中只需要保存一份此共享对象的代码。但并不是使用动态链接就一定比使用静态链接要优越。在某些情况下动态链接可能带来一些性能上损害。
 
 
 
GCC编译器的几个组成部分
 
预处理(cpp)、编译器(ccl)、汇编器(as)、链接器(ld)
 
 
 
补充：
 
1) 预编译
 
将.c 文件转化成.i文件 使用的gcc命令是：gcc–E  对应于预处理命令cpp
 
2) 编译
 
将.c/.h文件转换成.s文件 使用的gcc命令是：gcc–S 对应于编译命令 cc –S
 
3) 汇编
 
将.s 文件转化成.o文件 使用的gcc 命令是：gcc–c 对应于汇编命令是 as
 
4) 链接
 
将.o文件转化成可执行程序 使用的gcc命令是： gcc  对应于链接命令是 ld
 
总结起来编译过程就上面的四个过程：预编译处理(.c) －－>编译、优化程序（.s、.asm）－－>汇编程序(.obj、.o、.a、.ko)－－> 链接程序（.exe、.elf、.axf等）。
 
补充2：
 
解释型
 
解释则不同，解释型语言编写的程序不需要编译。解释型语言在运行的时候才翻译，比如VB语言，在执行的时候，专门有一个解释器能够将VB语言翻译成机器语言，每个语句都是执行的时候才翻译。这样解释型语言每执行一次就要翻译一次，效率比较低。
 
 
转载 ：http://m.blog.csdn.net/article/details?id=51398353

本篇我们开始进入Java的学习，首先在学习如何编写Java语言前要先了解Java程序的基本结构。
 
一、Java程序的基本结构
 
　　一个Java程序的基本结构大体可以分为包、类、main()主方法、标识符、关键字、语句和注释等，如下：
 
 
 1 package hello;                                                // 定义包
 2 
 3 public class Structure {                                    // 创建类
 4 
 5     static int num = 1;                                // 定义类的成员变量
 6     
 7     public static void main(String[] args) {                // 定义主方法
 8         
 9         String str = "http://www.cnblogs.com/adamjwh/";        // 定义局部变量
10         
11         System.out.println(num);                            // 输出成员变量的值
12         
13         System.out.println(str);                            // 输出局部变量的值
14         
15     }
16 
17 }
 
 
　　我们来逐一分析一下每一条语句，过多的概念我就不详述了，只说最基本的。
 
　　第一条语句“package hello;”定义了Java程序中类所在的包是hello，hello是一个标识符，由程序员自己定义，package是关键字。注意：标识符和关键字区分大小写。
 
　　第二条语句“public class Structure”用于创建一个名为Structure的类，类名由程序员自己定义，其中public及class是关键字，关于public和static的用法会在后续篇章中提到。
 
　　第三条语句“static int num = 1;”定义了类的成员变量，static和int都是关键字，而num是一个标识符，由程序员自己定义。
 
　　第四条语句“public static void main(String[] args)”是类的主方法，Java程序从这里开始执行，除了可以将“String[] args”改为“String args[]”外，不可改变本条语句的任何部分。
 
　　第五条语句“String str = "http://www.cnblogs.com/adamjwh”是在主方法中定义了一个局部变量，String是一个类，用于创建字符串对象（说简单点就是说，如果你想创建一条字符串，就使用String类），str是局部变量的名称，为程序员自己定义的一个标识符，而后面引号中的网址是局部变量str的值，“=”为赋值运算符。
 
　　第六条语句“System.out.println(num);”是输出语句，这是输出语句的固定写法，注意区分大小写，输出换行为println，不换行为print。
 
　　第七条语句同样为输出语句，执行将输出str的值，即http://www.cnblogs.com/adamjwh。
 
二、标识符和关键字
 
　　那么说了这么多是不是觉得好复杂啊，标识符、关键字都是什么。其实标识符可以简单理解为一个名字，用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。
 
　　例如，定义一个变量i并赋值为100，那么我们可以写出如下代码： int i = 100; 
 
　　这就是一个典型的赋值语句，其中int是定义一个整型数，i就是标识符，由程序员自己起名，但有一定的规则，简单点来说就是由字母、数字、下划线和美元符号组成，第一个字符不能为数字，并且区分大小写，不能为关键字或保留字。
 
　　我们可以举几个例子看看，合法标识符如name、user、_u8080、tc_bvt等等，非法标识符如5work、7fix等等。
 
　　上面提到的关键字和保留字，是Java语言中已经被赋予特定意义的一组单词，不可作为标识符使用，比如上面代码中的int就是关键字，至于java的关键字有哪些我就不过多的描述了，毕竟网上有很多很详细的介绍，我们还是主要从代码入手。
 
 三、基本数据类型
 
　　了解了上面的Java程序的基本结构后是不是对Java有一定的感觉了呢，那么编写程序肯定要用到许许多多数据，那Java中的数据又是如何分类及编写的呢？
 
　　在Java中有8种数据类型，其中6种是数值类型，另外两种分别是字符类型和布尔类型，如下：
 
 
 1 public class Type {
 2     
 3     /* 整数类型 */
 4     byte myByte = 45;                // byte型变量，占一个字节，取值范围-128~127
 5     short myShort = 100;            // short型变量，也即短整型，占两个字节，取值范围-32768~32767
 6     int myInt = 450;                // int型变量，也即整型，占四个字节，取值范围-2147483648~2147483647
 7     long myLong = 45261636L;        // long型变量，也即长整型，占八个字节，取值范围-9223372036854775808~9223372036854775807
 8     
 9     /* 浮点类型 */
10     float myFloat = 15.621F;        // 单精度浮点型，占四个字节，结尾必须加'F'或'f'，如果不加自动定义为double型变量，取值范围1.4E-45~3.4028235E-38
11     double myDouble = 15.621D;        // 双精度浮点型，占八个字节，结尾可以加'D'或'd'，也可不加，取值范围4.9E-324~1.7976931348623157E-308
12     
13     /* 字符类型 */ 
14     char myChar = 'a';                // 字符类型变量，用于存储单个字符，占两个字节，需用单引号括起来
15     
16     /* 布尔类型 */
17     boolean myBoolean = true;        // 布尔类型又称逻辑类型，只有true和false两个值，分别代表“真”和“假”
18 }
 
 
　　当我们要定义一个变量的时候，先判断变量的数据类型，再从上方8种类型中选择合适的类型使用即可，定义方法就如上方代码，以“[数据类型] [变量名] = [值]”的形式即可，其中变量名需自起名，满足上面提到的标识符的几个条件。
 
　　在字符类型中还有一种特殊的字符，以反斜线“\”开头，后跟一个或多个字符，具有特定的含义，叫做转义字符。
 
转义字符
含义
\ddd
1~3位八进制数据所表示的字符，如\456
\dxxxx
4位十六进制所表示的字符，如\0051
\'
单引号字符
\\
反斜杠字符
\t
垂直制表符，将光标移到下一个制表符的位置
\r
回车
\n
换行
\b
退格
\f
换页
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
　　
 
　　转义字符一般多用于输出，比如“\n”回车换行，“\t”移到下一制表位，如果想要输出单引号、双引号、下划线等字符时，也需要用转义字符进行输出。
 
四、变量与常量
 
　　刚刚我们提到了变量，接下来就说一下什么是变量和常量。在程序执行过程中，其值不能改变的称为常量，其值能改变的称为变量。变量与常量的声明都必须使用合法的标识符，所有变量与常量只有在声明之后才能使用。下面举一个声明变量的例子：
 
int age; // 声明int型变量 
char c = 'J' // 声明char型变量并赋值
 
　　既然叫变量那肯定是能改变的，现在我们对变量进行一下改变试试：
 
 
 1 public class Variable {
 2 
 3     public static void main(String[] args) {
 4         int num = 10;                                // 定义一个变量num，并赋给初值10
 5         System.out.println("num的初值为："+num);        // 输出当前变量num的值为10
 6         
 7         num = 100;                                    // 将100赋给num
 8         System.out.println("num现在的值为："+num);        // 输出现在变量num的值为100
 9     }
10 
11 }
 
 
　　上方是一段测试代码，我们首先定义一个变量，起名为num，然后对它赋一个初值10，再对这个变量赋值为100，看两次值的变化，运行结果如下所示：
 
　　
 
　　由此可以看出变量是在运行过程中其值可以改变。
 
　　而常量在整个程序中只能被赋值一次，需通过final关键字进行限定，如 final double PI = 3.1415926; ，为定义一个常量，名为PI（圆周率），我们如果单独定义一个变量是“double PI = 3.1415926;”，现在定义一个常量就是在double前加一个final关键字进行限定即可。
 
 
 
　　看到这里，是不是对Java的声明及定义有一些了解了呢？也许在之前大家也都见到了有些变量前有static这个关键字，它有什么用呢？这里就要说的变量的有效范围了。
 
　　变量的有效范围是指程序代码能够访问该变量的区域，若超出变量所在区域访问变量则编译时会出现错误。可分为“成员变量”和“局部变量”。
 
　　在类体中定义的变量被称为成员变量，成员变量在整个类中都有效，分为静态变量和实例变量两种。
 
class var {
    int x = 45;                 // 定义实例变量
    static int y = 90;        // 定义静态变量
}
 
　　其中x是实例变量，y是静态变量。如果成员变量的类型前面加上static，就被称为静态变量，静态变量的有效范围可以跨类，甚至可达到整个应用程序之内，也可用“类名.静态变量”的方式在其它类中使用（具体会在今后的篇幅中出现，想了解的可先行查阅资料）。
 
　　而在类的方法体中定义的变量（即“{”与“}”之间的声明变量）称之为局部变量。只在当前代码块中有效，简单点来说就是只在其所定义的大括号中有效。下面举一个例子：
 
 
 1 public class Val {
 2 
 3     static int times = 3;                                    // 定义成员变量times
 4     public static void main(String[] args) {
 5         int times = 4;                                        // 定义局部变量times
 6         
 7         System.out.println("times的值为：" + times);            // 将times输出
 8         System.out.println("静态变量times的值为：" + Val.times);        // 输出静态变量
 9     }
10 
11 }
 
 
　　输出结果为：
 
　　
 
　　从这段代码可以看出，首先在main方法外定义了一个成员变量times，并且是一个静态变量，而在main方法内又定义了一个局部变量times。这里有人就会问了，变量名不是不能相同吗？注意，这里第一个times是成员变量，作用范围是针对于整个类而言，而第二个times是局部变量，只在main方法内有效，所以两个重名并不冲突。但如果我们直接输出times，如第一个输出，输出结果为4，是局部变量起了作用，因为当局部变量与成员变量名字相同时，此时成员变量将被隐藏，即这个成员变量在此方法中暂时失效。如果我们想调用成员变量，需要使用“类名.静态变量”调用，如第二个输出，类名为Val，静态变量名为times，用“Val.times”即可调用静态变量的值为3。
 
五、代码注释
 
　　注释可以提高程序的可读性，注释包含的文字不会对程序产生任何影响，在Java中，代码注释主要有以下几种：
 
　　1. 单行注释　　
 
　　“//”为单行注释标记，从“//”开始到换行为止的所有内容均被注释而被编译器忽略。
 
// 这是一条单行注释
 
　　2. 多行注释
 
　　“/* */”为多行注释标记，符号“/*”与“*/”之间的所有内容均为注释内容，可以换行。
 
/*
    注释内容1
    注释内容2
    ......
*/
 
　　在多行注释中可以嵌套单行注释，比如下面的用法是正确的：
 
/*
    名称：博客园    // 时间：2018-1-20
*/
 
　　但在多行注释中不能嵌套多行注释。
 
　　3. 文档注释
 
　　“/** */”为文档注释标记。符号“/**”与“*/”之间的内容均为文档注释内容。当文档注释出现在任何声明之前时，会被Javadoc文档工具读取作为Javadoc文档内容。格式与多行注释相同。
 
1 /**
2     * name: Hello World
3     * time: 2018-1-20
4     * author: Adam
5 **/
 
 
 
　　下一篇将继续介绍Java语言基础中的运算符及类型转换。

前言
 
 
 
 
文章中介绍C语言程序执行过程中最基本的三种结构，包括有：顺序结构、分支结构、循环结构。理解和学习程序的执行过程，对于以后学习其他的编程语言，或者程序的调试，程序调Bug都有很好的帮助。
 
 
程序是什么？ 
 所谓的程序，就是一系列遵循一定规则和思想并能够正确完成指定工作的代码（也成为指令序列）。 
 其中，程序的一个部分是描述问题的每一个对象及它们之间的关系，这部分被成为数据结构（我认为程序设计中非常重要的一门课程）。 
 另外的一个部分是对这些对象进行处理的规则，当然这个就是算法。牛X的人，都是数学好的人~~ 
 因此有这么一种说法：程序=数据结构+算法 
 程序设计=数据结构+算法+程序设计方法+语言工具和环境
 
 
顺序结构
 
 
 
 
后面介绍的内容，基本上是基于C程序来介绍，通过实例和注释来解释知识点的重难点和用法。 
 顺序：顾名思义，从上到下、从左到右、从小到大……程序中的顺序结构便是从程序的main()函数入口，一条一条的指令执行，知道遇到程序结束的指令结束程序。
 
 
当然第一个程序必须是：“Hello world”
 
顺序结构程序代码：
 
//载入头文件 std 标准 io输入输出流 
#include<stdio.h>

/*
程序的入口函数 mian()函数 其中()中参数可以省略 
agrc参数表示是程序指令的个数 
agrv指针类型数组保存的是每一条指令在内存中的地址 
*/ 
int main(int agrc,char *agrv[]){

    //定义一个字符串数组 给s初始化的内容是 Hello world!
    char s[] = "Hello world!";
    //将需要输出的内容输出到console控制台 
    printf("%s",s);
    /*
    程序需要返回一个int类型的数据
    程序能正常终止 返回值为 0 异常终止 返回值 1 
    这里正常终止 设置为 0 
    */ 
    return 0;
} 
 
程序执行结果
 
 
 
 
 
整体看一下这个程序
 
 
 
输出结果可以看到“Hello world！”我们希望输出的内容输出到屏幕上了，可以看到程序执行了0.4415s，最后返回的结果是0，和我们的预期一样。
 
 
程序具体的每一句的代码的执行目的代码注释里面有详细解释。其中良好的程序编写人员都会有代码注释的习惯，方便别人阅读和自己回头的理解。这里注释的方式有两种，程序中均有体现。
 
 
程序运行流程：从main()入口函数进入程序，按照顺序的执行方式，一句一句的执行，定义char类型的字符串s，输出s，返回return，程序结束。很好理解。
 
 
分支结构
 
 
 
 
分支结构中需要知道if、else、elseif、switch case的用法
 
 
分支结构程序代码：
 
//载入头文件 std 标准 io输入输出流 
#include<stdio.h>

/*
程序的入口函数 mian()函数 其中()中参数可以省略 
agrc参数表示是程序指令的个数 
agrv指针类型数组保存的是每一条指令在内存中的地址 
*/ 
int main(int agrc,char *agrv[]){

    /*
    顺序结构
    */ 
    //定义一个字符串数组 给s初始化的内容是 Hello world!
    char s[] = "Hello world!";
    //将需要输出的内容输出到console控制台 
    printf("%s\n",s);

    /*
    分支结构 
    */
    int n;
    scanf("%d",&n);
    //if分支语句 括号内部判断是不是真 若为真 执行if内的语句
    //分支语句可以没有else 但有else 一定要有一个if与之对应
    //这里的括号内部判断的是一个数字 C语言中非0的数字均为真  
    if(3)
        printf("1:\t这是一个真语句!\n") ;

    //if -else -elseif 
    //判断输入的n与0的关系并输出 
    if(n>0)
        printf("2:\t%d大于0\n",n);
    else if(n == 0)
        printf("2:\t%d等于0\n",n);
    else
        printf("2:\t%d小于0\n",n);

    //分支嵌套 switch case
    if(n>0)
        printf("3:\t%d大于0\n",n);
    else
    {
        if(n == 0)
            printf("3:\t%d等于0\n",n); 
        else{
            switch(n){
                //若n的值是 -1的情况 
                case -1:
                    printf("3:\t%d小于0\n",n);
                    break;
                //若n的值是 -2的情况   
                case -2:
                    printf("3:\t%d小于0\n",n);
                    break;
                //其它情况 
                default:
                    printf("3:\t%d小于0\n",n);
                    break;
            }
        } 
    } 

    /*
    程序需要返回一个int类型的数据
    程序能正常终止 返回值为 0 异常终止 返回值 1 
    这里正常终止 设置为 0 
    */ 
    return 0;
} 
 
程序执行的结果：
 
 
 
 
 
说明3点：
 
 
 
变量的定义位置，C语言会将一个域中用的变量定义到所有程序指令的最前面，这里分支结构这块定义了一个n，程序能正常执行，和编译有关。 
 用C编译器的情况: gcc text.c; 
 用C++编译器的情况: g++ test.c 或者 g++ test.cpp 或者 g++ test.c (也就是用g++命令或者源文件后缀是cpp，则默认是用C++编译器)。 
 因为C++中没有这个说法，所以用g++编译不会出现问题。
switch中的break，break的作用：break语句通常用在循环语句和开关语句中。当break用于开关语句switch中时，可使程序跳出switch而执行switch以后的语句；如果没有break语句，则会从满足条件的地方（即与switch（表达式）括号中表达式匹配的case）开始执行，直到switch结构结束。
另外可以注意使用C语言中的唯一的三目运算符： 
 max = ( x > y ) ? x : y ; 
 代替了一下的代码，使用非常方便 
 if(x > y) 
 max = x; 
 else 
 max = y; 
 
 
循环结构
 
 
 
 
循环结构一般会结合着分支结构一起使用，完成对问题的求解。
 
 
循环结构程序代码：
 
//载入头文件 std 标准 io输入输出流 
#include<stdio.h>

/*
程序的入口函数 mian()函数 其中()中参数可以省略 
agrc参数表示是程序指令的个数 
agrv指针类型数组保存的是每一条指令在内存中的地址 
*/ 
int main(int agrc,char *agrv[]){

    /*
    顺序结构
    */ 
    //定义一个字符串数组 给s初始化的内容是 Hello world!
    char s[] = "Hello world!";
    //将需要输出的内容输出到console控制台 
    printf("%s\n",s);

    /*
    分支结构 
    */
    int n;
    scanf("%d",&n);
    //if分支语句 括号内部判断是不是真 若为真 执行if内的语句
    //分支语句可以没有else 但有else 一定要有一个if与之对应
    //这里的括号内部判断的是一个数字 C语言中非0的数字均为真  
    if(3)
        printf("1:\t这是一个真语句!\n") ;

    //if -else -elseif 
    //判断输入的n与0的关系并输出 
    if(n>0)
        printf("2:\t%d大于0\n",n);
    else if(n == 0)
        printf("2:\t%d等于0\n",n);
    else
        printf("2:\t%d小于0\n",n);

    //分支嵌套 switch case
    if(n>0)
        printf("3:\t%d大于0\n",n);
    else
    {
        if(n == 0)
            printf("3:\t%d等于0\n",n); 
        else{
            switch(n){
                //若n的值是 -1的情况 
                case -1:
                    printf("3:\t%d小于0\n",n);
                    break;
                //若n的值是 -2的情况   
                case -2:
                    printf("3:\t%d小于0\n",n);
                    break;
                //其它情况 
                default:
                    printf("3:\t%d小于0\n",n);
                    break;
            }
        } 
    } 
    /*
    循环结构
    */ 
    int m;
    //只要输入的内容不是文件结尾符 可以一直输入
    //循环内部可以控制结束条件 
    while(scanf("%d",&m) != EOF){
        //break
        //如果m的值等于0 后面的语句也不执行 或者写为 m==0 
        //调出while循环 执行循环外部的程序指令 
        if(!m)
            break;
        int sum = 0;
        for(int i=0;i<m;i++){
            //计算 0~m-1的和 
            sum += i;
        }
        printf("0~%d的和是%d\n",m-1,sum);
        //continue
        //如果m的值不等于0 后面的语句不执行
        //while的头入口继续循环 
        if(m!=0)
            continue;
        //执行的结果中可以发现这里从未执行 思考一下 why? 
        printf("这里执行了吗？\n");
    } 

    /*
    程序需要返回一个int类型的数据
    程序能正常终止 返回值为 0 异常终止 返回值 1 
    这里正常终止 设置为 0 
    */ 
    return 0;
} 
 
程序执行结果：
 
 
 
 
 
说明几点：
 
 
 
for循环使用最多，一般情况可以表示任何循环，和while循环均是当型循环，先判断，后执行。do{}while属于直到型循环，先做循环再判断，程序用应用不多，程序中也没有体现。
自增，自减符，++a、–a、a++、a–；符号在前表示的是：先做自增或者自减运算后以运算后的数值进行接下来的程序执行，符号在后表示的是：以当前值进行程序执行，执行结束后做自增自减运算进行下次程序执行。（在程序中可以体现）
for循环中循环语句可以是单个语句、空语句也可以是复合语句；三个表达式可以是任意类型，其中的分号”;”不能省略。
 
 
自增自减程序代码：
 
#include<stdio.h>

int main(){
    int sum = 0;
    printf("符号在后自增：%d\n",sum++);
    printf("符号在前自增：%d\n",++sum);
    return 0;
} 
 
程序运行结果： 
 
 
结语
 
 
 
 
有关C语言程序三种基本结构，顺序结构、分支结构、循环结构的主要内容和知识都已经在程序中有所体现。 
 文章内容是博主手写，难免出现错误和瑕疵，有错误请指出，有问题请积极留言一起交流。