C语言总结1.0

 

C 语言

 /*C 程序结构

在我们学习 C 语言的基本构建块之前，让我们先来看看一个最小的 C 程序结构，在接下来的章节中可以以此作为参考。
C Hello World 实例

C 程序主要包括以下部分：
预处理器指令
函数
变量
语句 & 表达式
注释
让我们看一段简单的代码，可以输出单词 "Hello World"：

 
#include <stdio.h>

int main(void)
{
   //我的第一个 C 程序 
   printf("Hello, World! \n");
   
   return 0;
} 
接下来我们讲解一下上面这段程序：
程序的第一行 #include <stdio.h> 是预处理器指令，告诉 C 编译器在实际编译之前要包含 stdio.h 文件。
下一行 int main() 是主函数，程序从这里开始执行。
下一行 /.../ 将会被编译器忽略，这里放置程序的注释内容。它们被称为程序的注释。
下一行 printf(...) 是 C 中另一个可用的函数，会在屏幕上显示消息 "Hello, World!"。
下一行 return 0; 终止 main() 函数，并返回值 0。
编译 & 执行 C 程序

接下来让我们看看如何把源代码保存在一个文件中，以及如何编译并运行它。下面是简单的步骤：
打开一个文本编辑器，添加上述代码。
保存文件为 hello.c。
打开命令提示符，进入到保存文件所在的目录。
键入 gcc hello.c，输入回车，编译代码。
如果代码中没有错误，命令提示符会跳到下一行，并生成 a.out 可执行文件。
现在，键入 a.out 来执行程序。
您可以看到屏幕上显示 "Hello World"。
$ gcc hello.c
$ ./a.out
Hello, World!
请确保您的路径中已包含 gcc 编译器，并确保在包含源文件 hello.c 的目录中运行它。*/
/*C 基本语法

我们已经看过 C 程序的基本结构，这将有助于我们理解 C 语言的其他基本的构建块。
C 的令牌（Tokens）

C 程序由各种令牌组成，令牌可以是关键字、标识符、常量、字符串值，或者是一个符号。例如，下面的 C 语句包括五个令牌：
printf("Hello, World! \n");
这五个令牌分别是：
printf
(
"Hello, World! \n"
)
;
分号 ;

在 C 程序中，分号是语句结束符。也就是说，每个语句必须以分号结束。它表明一个逻辑实体的结束。
例如，下面是两个不同的语句：
printf("Hello, World! \n");
return 0;
注释

注释就像是 C 程序中的帮助文本，它们会被编译器忽略。它们以 /* 开始，以字符 / 终止，如下所示：
/* 我的第一个 C 程序 /
您不能在注释内嵌套注释，注释也不能出现在字符串或字符值中。
标识符

C 标识符是用来标识变量、函数，或任何其他用户自定义项目的名称。
一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。
C 标识符内不允许出现标点字符，比如 @、$ 和 %。C 是区分大小写的编程语言。
因此，在 C 中，Manpower 和 manpower 是两个不同的标识符。下面列出几个有效的标识符：
mohd       zara    abc   move_name  a_123
myname50   _temp   j     a23b9      retVal
关键字

下表列出了 C 中的保留字。这些保留字不能作为常量名、变量名或其他标识符名称。
auto    else    long    switch
break    enum    register    typedef
case    extern    return    union55
char    float    short    unsigned
const    for    signed    void
continue    goto    sizeof    volatile
default    if    static    while
do    int    struct    _Packed
double               

C 中的空格

只包含空格的行，被称为空白行，可能带有注释，C 编译器会完全忽略它。
在 C 中，空格用于描述空白符、制表符、换行符和注释。空格分隔语句的各个部分，
让编译器能识别语句中的某个元素（比如 int）在哪里结束，下一个元素在哪里开始。因此，在下面的语句中：
int age;
在这里，int 和 age 之间必须至少有一个空格字符（通常是一个空白符），这样编译器才能够区分它们。另一方面，在下面的语句中：
fruit = apples + oranges;   // 获取水果的总数
fruit 和 =，或者 = 和 apples 之间的空格字符不是必需的，但是为了增强可读性，您可以根据需要适当增加一些空格。*/

/* 
#include <stdio.h>
int main()
{
    printf(" hello word");
    return 0;
    
}*/
  
  
   
/*
C 变量

变量其实只不过是程序可操作的存储区的名称。C 中每个变量都有特定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，运算符可应用于变量上。
变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写字母是不同的，因为 C 是大小写敏感的。基于前一章讲解的基本类型，有以下几种基本的变量类型：
类型    描述
char    通常是一个八位字节（一个字节）。这是一个整数类型。
int    对机器而言，整数的最自然的大小。10 10.0 10.00
float    单精度浮点值。
double    双精度浮点值。
void    表示类型的缺失。

C 语言也允许定义各种其他类型的变量，比如枚举、指针、数组、结构、共用体等等，这将会在后续的章节中进行讲解，本章节我们先讲解基本变量类型。
C 中的变量定义

变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表，如下所示：
type variable_list;
在这里，type 必须是一个有效的 C 数据类型，可以是 char、w_char、int、float、double、bool 或任何用户自定义的对象，variable_list 可以由一个或多个标识符名称组成，多个标识符之间用逗号分隔。下面列出几个有效的声明：
int    i, j, k;
char   c, ch;
float  f, salary;
double d;
行 int i, j, k; 声明并定义了变量 i、j 和 k，这指示编译器创建类型为 int 的名为 i、j、k 的变量。
变量可以在声明的时候被初始化（指定一个初始值）。初始化器由一个等号，后跟一个常量表达式组成，如下所示：
type variable_name = value;
下面列举几个实例：
extern int d = 3, f = 5;    // d 和 f 的声明 
int d = 3, f = 5;           // 定义并初始化 d 和 f
byte z = 22;                // 定义并初始化 z
char x = 'x';               // 变量 x 的值为 'x'
不带初始化的定义：带有静态存储持续时间的变量会被隐式初始化为 NULL（所有字节的值都是 0），其他所有变量的初始值是未定义的。
C 中的变量声明

变量声明向编译器保证变量以给定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。
当您使用多个文件且只在其中一个文件中定义变量时（定义变量的文件在程序连接时是可用的），变量声明就显得非常有用。您可以使用 extern 关键字在任何地方声明一个变量。虽然您可以在程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。
实例

尝试下面的实例，其中，变量在头部就已经被声明，但它们是在主函数内被定义和初始化的：
*/
/*
#include <stdio.h>

// 变量声明
extern int a, b;
extern int c;
extern float f;

int main ()
{
  //变量定义 
  int a, b;
  int c;
  float f;
 
  // 实际初始化
  a = 10;
  b = 20;
  
  c = a + b;
  printf("value of c : %d \n", c);

  f = 70.0/3.0;
  printf("value of f : %f \n", f);
 
  return 0;
}*/
/*
当上面的代码被编译和执行时，它会产生下列结果：
value of c : 30
value of f : 23.333334
同样的，在函数声明时，提供一个函数名，而函数的实际定义则可以在任何地方进行。例如：
// 函数声明
int func();

int main()
{
    // 函数调用
    int i = func();
}

// 函数定义
int func()
{
    return 0;
}
C 中的左值（Lvalues）和右值（Rvalues）

C 中有两种类型的表达式：
左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。
变量是左值，因此可以出现在赋值号的左边。数值型的字面值是右值，因此不能被赋值，不能出现在赋值号的左边。下面是一个有效的语句：
int g = 20;
但是下面这个就不是一个有效的语句，会生成编译时错误：
10 = 20;
*/
/*
#include <stdio.h>

// 变量声明
extern int a, b;
extern int c;
extern float f;

int main ()
{
  // 变量定义 
  int a, b;
  int c;
  float f;
 
  // 实际初始化 
  a = 10;
  b = 2;
   
  c = a/b;
  printf("value of c : %d \n", c);

  f = 70.0/3.0;
  printf("value of f : %f \n", f);
 
  return 0;
}*/
/* 
C 常量

常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。
常量可以是任何的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。
常量就像是常规的变量，只不过常量的值在定义后不能进行修改。
整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。
整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。
下面列举几个整数常量的实例：
212         //合法的 
215u        // 合法的
0xFeeL      //合法的
078         // 非法的：8 不是八进制的数字 
032UU       //非法的：不能重复后缀 
以下是各种类型的整数常量的实例：
85         // 十进制 
0213       // 八进制 
0x4b       // 十六进制
30         // 整数 
30u        // 无符号整数
30l        // 长整数 
30ul       // 无符号长整数 
浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。
当使用小数形式表示时，必须包含小数点、指数，或同时包含两者。当使用指数形式表示时，必须包含整数部分、小数部分，或同时包含两者。带符号的指数是用 e 或 E 引入的。
下面列举几个浮点常量的实例：
3.14159       // 合法的 
314159E-5L    // 合法的 
510E          // 非法的：不完整的指数 
210f          // 非法的：没有小数或指数 
.e55          // 非法的：缺少整数或分数 
字符常量

字符常量是括在单引号中，例如，'x' 可以存储在 char 类型的简单变量中。
字符常量可以是一个普通的字符（例如 'x'）、一个转义序列（例如 '\t'），或一个通用的字符（例如 '\u02C0'）。
在 C 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（\n）或制表符（\t）等。下表列出了一些这样的转义序列码：
转义序列    含义
\\    \ 字符
\'    ' 字符
\"    " 字符
\?    ? 字符
\a    警报铃声
    退格键
\f    换页符
\n    换行符
\r    回车
\t    水平制表符
\v    垂直制表符
\ooo    一到三位的八进制数
\xhh . . .    一个或多个数字的十六进制数
下面的实例显示了一些转义序列字符：
#include <stdio.h>

int main()
{
   printf("Hello\tWorld\n\n");

   return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：
Hello   World

字符串常量

字符串字面值或常量是括在双引号 "" 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。
您可以使用空格做分隔符，把一个很长的字符串常量进行分行。
下面的实例显示了一些字符串常量。下面这三种形式所显示的字符串是相同的。
"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"
定义常量

在 C 中，有两种简单的定义常量的方式：
使用 #define 预处理器。
使用 const 关键字。
#define 预处理器

下面是使用 #define 预处理器定义常量的形式：
#define identifier value
具体请看下面的实例：
#include <stdio.h>

#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'

int main()
{

   int area;  
  
   area = LENGTH * WIDTH;
   printf("value of area : %d", area);
   printf("%c", NEWLINE);

   return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：
value of area : 50
const 关键字

您可以使用 const 前缀声明指定类型的常量，如下所示：
const type variable = value;
具体请看下面的实例：
*//*
#include <stdio.h>

int main()
{
   const int  LENGTH = 10;
   const int  WIDTH  = 5;
   const char NEWLINE = '\n';
   int area;  
   
   area = LENGTH * WIDTH;
   printf("value of area : %d", area);
   printf("%c", NEWLINE);

   return 0;
}*/
/*
当上面的代码被编译和执行时，它会产生下列结果：
value of area : 50
*/
/*
#include<stdio.h>
int main()
{
    printf("Hello \t world\n\n");
    return 0;
    
} */
/*
#include <stdio.h>

#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'

int main()
{

   int area;  
  
   area = LENGTH * WIDTH;
   printf("value of area : %d", area);
   printf("%c", NEWLINE);

   return 0;
}
*/

/*
C 存储类

存储类定义 C 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C 程序中可用的存储类：
auto
register
static
extern
auto 存储类

auto 存储类是所有局部变量默认的存储类。
{
   int mount;
   auto int month;
}
上面的实例定义了两个带有相同存储类的变量，auto 只能用在函数内，即 auto 只能修饰局部变量。
register 存储类

register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。
{
   register int  miles;
}
寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。
static 存储类

static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。
static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。
在 C 编程中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。
#include <stdio.h>
 
//函数声明 
void func(void);
 
static int count = 5; // 全局变量 
 
main()
{
   while(count--)
   {
      func();
   }
   return 0;
}
//函数定义 
void func( void )
{
   static int i = 5; // 局部静态变量 
   i++;

   printf("i is %d and count is %d\n", i, count);
}
可能您现在还无法理解这个实例，因为我已经使用了函数和全局变量，这两个概念目前为止还没进行讲解。即使您现在不能完全理解，也没有关系，后续的章节我们会详细讲解。当上面的代码被编译和执行时，它会产生下列结果：
i is 6 and count is 4
i is 7 and count is 3
i is 8 and count is 2
i is 9 and count is 1
i is 10 and count is 0
extern 存储类

extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 'extern' 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。
当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。
extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：
第一个文件：main.c
#include <stdio.h>
 
int count ;
extern void write_extern();
 
main()
{
   count = 5;
   write_extern();
}
第二个文件：support.c
#include <stdio.h>
 
extern int count;
 
void write_extern(void)
{
   printf("count is %d\n", count);
}
在这里，第二个文件中的 extern 关键字用于声明已经在第一个文件 main.c 中定义的 count。现在 ，编译这两个文件，如下所示：
 $gcc main.c support.c
这会产生 a.out 可执行程序，当程序被执行时，它会产生下列结果：
count is 5
*//*
#include <stdio.h>
 
int count ;
extern void write_extern();
 
main()
{
   count = 5;
   write_extern();
}
#include <stdio.h>
 
extern int count;
 
void write_extern(void)
{
   printf("count is %d\n", count);
}*/
/*C 运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C 语言内置了丰富的运算符，并提供了以下类型的运算符：
算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
杂项运算符
本章将逐一介绍算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和杂项运算符。
算术运算符

下表显示了 C 语言支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：
运算符    描述    实例
+    把两个操作数相加    A + B 将得到 30
-    从第一个操作数中减去第二个操作数    A - B 将得到 -10
*    把两个操作数相乘    A * B 将得到 200
/    分子除以分母    B / A 将得到 2
%    取模运算符，整除后的余数    B % A 将得到 0
++    自增运算符，整数值增加 1    A++ 将得到 11
--    自减运算符，整数值减少 1    A-- 将得到 9
实例

请看下面的实例，了解 C 语言中所有可用的算术运算符：
*/
/*
#include <stdio.h>

int main()
{
   int a = 21;
   int b = 10;
   int c ;

   c = a + b;
   printf("Line 1 - c 的值是 %d\n", c );
   c = a - b;
   printf("Line 2 - c 的值是 %d\n", c );
   c = a * b;
   printf("Line 3 - c 的值是 %d\n", c );
   c = a / b;
   printf("Line 4 - c 的值是 %d\n", c ); 
   c = a % b;
   printf("Line 5 - c 的值是 %d\n", c );
   c = a++;  // 赋值后再加 1 ，c 为 21，a 为 22
   printf("Line 6 - c 的值是 %d\n", c );
   c = a--;  // 赋值后再减 1 ，c 为 22 ，a 为 21
   printf("Line 7 - c 的值是 %d\n", c );

}

/*
当上面的代码被编译和执行时，它会产生下列结果：
Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 21
Line 7 - c 的值是 22
以下实例演示了 a++ 与 ++a 的区别： a++ 和 ++a的相同点都是给a+1，不同点是a++是先赋值再+1，而++a则是先+1再参赋值。
实例

#include <stdio.h>
int main()
{
int c;
int a = 10;
c = a++;
printf("先赋值后运算：\n");
printf("Line 1 - c 的值是 %d\n", c );
printf("Line 2 - a 的值是 %d\n", a );
a = 10;
c = a--;
printf("Line 3 - c 的值是 %d\n", c );
printf("Line 4 - a 的值是 %d\n", a );
printf("先运算后赋值：\n");
a = 10;
c = ++a;
printf("Line 5 - c 的值是 %d\n", c );
printf("Line 6 - a 的值是 %d\n", a );
a = 10;
c = --a;
printf("Line 7 - c 的值是 %d\n", c );
printf("Line 8 - a 的值是 %d\n", a );
}

以上程序执行输出结果为：
先赋值后运算：
Line 1 - c 的值是 10
Line 2 - a 的值是 11
Line 3 - c 的值是 10
Line 4 - a 的值是 9
先运算后赋值：
Line 5 - c 的值是 11
Line 6 - a 的值是 11
Line 7 - c 的值是 9
Line 8 - a 的值是 9

关系运算符

下表显示了 C 语言支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：
运算符    描述    实例
==    检查两个操作数的值是否相等，如果相等则条件为真。    (A == B) 不为真。
!=    检查两个操作数的值是否相等，如果不相等则条件为真。    (A != B) 为真。
>    检查左操作数的值是否大于右操作数的值，如果是则条件为真。    (A > B) 不为真。
<    检查左操作数的值是否小于右操作数的值，如果是则条件为真。    (A < B) 为真。
>=    检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。    (A >= B) 不为真。
<=    检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。    (A <= B) 为真。
实例

请看下面的实例，了解 C 语言中所有可用的关系运算符：
*/
/*
#include <stdio.h>

int main()
{
   int a = 21;
   int b = 10;
   int c ;

   if( a == b )
   {
      printf("Line 1 - a 等于 b\n" );
   }
   else
   {
      printf("Line 1 - a 不等于 b\n" );
   }
   if ( a < b )
    { 
            printf("Line 2 - a 小于 b\n" );
    }
    else
    {
            printf("Line 2 - a 不小于 b\n" );
    }
   if ( a > b )
   {
      printf("Line 3 - a 大于 b\n" );
   }
   else
   {
      printf("Line 3 - a 不大于 b\n" );
   }
   //    改变 a 和 b 的值 
   a = 5;
   b = 20;
   if ( a <= b )
    {       printf("Line 4 - a 小于或等于 b\n" );
    }
    if ( b >= a )
   {
      printf("Line 5 - b 大于或等于 b\n" );
   }
}
当上面的代码被编译和执行时，它会产生下列结果：
Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 b
逻辑运算符

下表显示了 C 语言支持的所有关系逻辑运算符。假设变量 A 的值为 1，变量 B 的值为 0，则：
运算符    描述    实例
&&    称为逻辑与运算符。如果两个操作数都非零，则条件为真。    (A && B) 为假。
||    称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。    (A || B) 为真。
!    称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。    !(A && B) 为真。
实例

请看下面的实例，了解 C 语言中所有可用的逻辑运算符：
/*
#include <stdio.h>

int main()
{
   int a = 5;
   int b = 20;
   int c ;

   if ( a && b )
   {
      printf("Line 1 - 条件为真\n" );
   }
   if ( a || b )
   {
      printf("Line 2 - 条件为真\n" );
   }
   // 改变 a 和 b 的值 
   a = 0;
   b = 10;
   if ( a && b )
   {
      printf("Line 3 - 条件为真\n" );
   }
   else
   {
      printf("Line 3 - 条件不为真\n" );
   }
   if ( !(a && b) )
   {
      printf("Line 4 - 条件为真\n" );
   }
}
当上面的代码被编译和执行时，它会产生下列结果：
Line 1 - 条件为真
Line 2 - 条件为真
Line 3 - 条件不为真
Line 4 - 条件为真

位运算符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：
p    q    p & q    p | q    p ^ q
0    0    0    0    0
0    1    0    1    1
1    1    1    1    0
1    0    0    1    1
假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：
A = 0011 1100
B = 0000 1101
--------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A  = 1100 0011
下表显示了 C 语言支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：
运算符    描述    实例
&    按位与操作，按二进制位进行“与”运算。运算规则： 
0&0=0;
0&1=0;
1&0=0;
1&1=1;
(A & B) 将得到 12，即为 0000 1100
|    按位或运算符，按二进制位进行“或”运算。运算规则：
0|0=0;
0|1=1;
1|0=1;
1|1=1;
(A | B) 将得到 61，即为 0011 1101
^    异或运算符，按二进制位进行“异或”运算。运算规则：
0^0=0;
0^1=1;
1^0=1;
1^1=0
(A ^ B) 将得到 49，即为 0011 0001
~    取反运算符，按二进制位进行“取反”运算。运算规则：
~1=0;
~0=1;
(~A ) 将得到 -61，即为 1100 0011，2 的补码形式，带符号的二进制数。
<<    二进制左移运算符。左操作数的值向左移动右操作数指定的位数（左边的二进制位丢弃，右边补0）。    A << 2 将得到 240，即为 1111 0000
>>    二进制右移运算符。左操作数的值向右移动右操作数指定的位数（正数左补0，负数左补1，右边丢弃）。    A >> 2 将得到 15，即为 0000 1111
实例

请看下面的实例，了解 C 语言中所有可用的位运算符：
*//*
#include <stdio.h>

int main()
{

   unsigned int a = 60; // 60 = 0011 1100   
   unsigned int b = 13; // 13 = 0000 1101 
   int c = 0;           

   c = a & b;       // 12 = 0000 1100 
   printf("Line 1 - c 的值是 %d\n", c );

   c = a | b;       // 61 = 0011 1101
   printf("Line 2 - c 的值是 %d\n", c );

   c = a ^ b;       // 49 = 0011 0001
   printf("Line 3 - c 的值是 %d\n", c );

   c = ~a;          //-61 = 1100 0011 
   printf("Line 4 - c 的值是 %d\n", c );

   c = a << 2;     // 240 = 1111 0000 
   printf("Line 5 - c 的值是 %d\n", c );

   c = a >> 2;     // 15 = 0000 1111 
   printf("Line 6 - c 的值是 %d\n", c );
}*//*
当上面的代码被编译和执行时，它会产生下列结果：
Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15
赋值运算符

下表列出了 C 语言支持的赋值运算符：
运算符    描述    实例
=    简单的赋值运算符，把右边操作数的值赋给左边操作数    C = A + B 将把 A + B 的值赋给 C
+=    加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数    C += A 相当于 C = C + A
-=    减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数    C -= A 相当于 C = C - A
*=    乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数    C *= A 相当于 C = C * A
/=    除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数    C /= A 相当于 C = C / A
%=    求模且赋值运算符，求两个操作数的模赋值给左边操作数    C %= A 相当于 C = C % A
<<=    左移且赋值运算符    C <<= 2 等同于 C = C << 2
>>=    右移且赋值运算符    C >>= 2 等同于 C = C >> 2
&=    按位与且赋值运算符    C &= 2 等同于 C = C & 2
^=    按位异或且赋值运算符    C ^= 2 等同于 C = C ^ 2
|=    按位或且赋值运算符    C |= 2 等同于 C = C | 2
实例

请看下面的实例，了解 C 语言中所有可用的赋值运算符：
#include <stdio.h>

int main()
{
   int a = 21;
   int c ;

   c =  a;
   printf("Line 1 - =  运算符实例，c 的值 = %d\n", c );

   c +=  a;
   printf("Line 2 - += 运算符实例，c 的值 = %d\n", c );

   c -=  a;
   printf("Line 3 - -= 运算符实例，c 的值 = %d\n", c );

   c *=  a;
   printf("Line 4 - *= 运算符实例，c 的值 = %d\n", c );

   c /=  a;
   printf("Line 5 - /= 运算符实例，c 的值 = %d\n", c );

   c  = 200;
   c %=  a;
   printf("Line 6 - %= 运算符实例，c 的值 = %d\n", c );

   c <<=  2;
   printf("Line 7 - <<= 运算符实例，c 的值 = %d\n", c );

   c >>=  2;
   printf("Line 8 - >>= 运算符实例，c 的值 = %d\n", c );

   c &=  2;
   printf("Line 9 - &= 运算符实例，c 的值 = %d\n", c );

   c ^=  2;
   printf("Line 10 - ^= 运算符实例，c 的值 = %d\n", c );

   c |=  2;
   printf("Line 11 - |= 运算符实例，c 的值 = %d\n", c );

}
当上面的代码被编译和执行时，它会产生下列结果：
Line 1 - =  运算符实例，c 的值 = 21
Line 2 - += 运算符实例，c 的值 = 42
Line 3 - -= 运算符实例，c 的值 = 21
Line 4 - *= 运算符实例，c 的值 = 441
Line 5 - /= 运算符实例，c 的值 = 21
Line 6 - %= 运算符实例，c 的值 = 11
Line 7 - <<= 运算符实例，c 的值 = 44
Line 8 - >>= 运算符实例，c 的值 = 11
Line 9 - &= 运算符实例，c 的值 = 2
Line 10 - ^= 运算符实例，c 的值 = 0
Line 11 - |= 运算符实例，c 的值 = 2
杂项运算符

下表列出了 C 语言支持的其他一些重要的运算符，包括 sizeof()、&、* 和 ? :。
运算符    描述    实例
sizeof()    返回变量的大小。    sizeof(a) 将返回 4，其中 a 是整数。
&    返回变量的地址。    &a; 将给出变量的实际地址。
*    指向一个变量。    *a; 将指向一个变量。
? :    条件表达式    如果条件为真 ? 则值为 X : 否则值为 Y
实例

请看下面的实例，了解 C 语言中所有可用的杂项运算符：
#include <stdio.h>

int main()
{
   int a = 4;
   short b;
   double c;
   int* ptr;

   // & 和 * 运算符实例 
   ptr = &a;    // 'ptr' 现在包含 'a' 的地址 
   printf("a 的值是 %d\n", a);
   printf("*ptr 是 %d\n", *ptr);

   // 三元运算符实例 
   a = 10;
   b = (a == 1) ? 20: 30;
   printf( "b 的值是 %d\n", b );

   b = (a == 10) ? 20: 30;
   printf( "b 的值是 %d\n", b );
}
当上面的代码被编译和执行时，它会产生下列结果：
a 的值是 4
*ptr 是 4
b 的值是 30
b 的值是 20
C 中的运算符优先级

运算符的优先级确定表达式中项的组合。这会影响到一个表达式如何计算。某些运算符比其他运算符有更高的优先级，例如，乘除运算符具有比加减运算符更高的优先级。
例如 x = 7 + 3 * 2，在这里，x 被赋值为 13，而不是 20，因为运算符 * 具有比 + 更高的优先级，所以首先计算乘法 3*2，然后再加上 7。
下表将按运算符优先级从高到低列出各个运算符，具有较高优先级的运算符出现在表格的上面，具有较低优先级的运算符出现在表格的下面。在表达式中，较高优先级的运算符会优先被计算。
类别     运算符     结合性 
后缀     () [] -> . ++ - -      从左到右 
一元     + - ! ~ ++ - - (type)* & sizeof     从右到左 
乘除     * / %     从左到右 
加减     + -     从左到右 
移位     << >>     从左到右 
关系     < <= > >=     从左到右 
相等     == !=     从左到右 
位与 AND     &     从左到右 
位异或 XOR     ^     从左到右 
位或 OR     |     从左到右 
逻辑与 AND     &&     从左到右 
逻辑或 OR     ||     从左到右 
条件     ?:     从右到左 
赋值     = += -= *= /= %=>>= <<= &= ^= |=     从右到左 
逗号     ,     从左到右 
实例

请看下面的实例，了解 C 语言中运算符的优先级：
#include <stdio.h>

int main()
{
   int a = 20;
   int b = 10;
   int c = 15;
   int d = 5;
   int e;
 
   e = (a + b) * c / d;      // ( 30 * 15 ) / 5
   printf("(a + b) * c / d 的值是 %d\n",  e );

   e = ((a + b) * c) / d;    // (30 * 15 ) / 5
   printf("((a + b) * c) / d 的值是 %d\n" ,  e );

   e = (a + b) * (c / d);   // (30) * (15/5)
   printf("(a + b) * (c / d) 的值是 %d\n",  e );

   e = a + (b * c) / d;     //  20 + (150/5)
   printf("a + (b * c) / d 的值是 %d\n" ,  e );
  
   return 0;
}/*
当上面的代码被编译和执行时，它会产生下列结果：
(a + b) * c / d 的值是 90
((a + b) * c) / d 的值是 90
(a + b) * (c / d) 的值是 90
a + (b * c) / d 的值是 50
*/
/*
c 语句
判断语句

C 语言提供了以下类型的判断语句。点击链接查看每个语句的细节。
语句                        描述
if 语句                        一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。
if...else 语句                一个 if 语句 后可跟一个可选的 else 语句，else 语句在布尔表达式为假时执行。
嵌套 if 语句                您可以在一个 if 或 else if 语句内使用另一个 if 或 else if 语句。
switch 语句                    一个 switch 语句允许测试一个变量等于多个值时的情况。
嵌套 switch 语句            您可以在一个 switch 语句内使用另一个 switch 语句。
? : 运算符

我们已经在前面的章节中讲解了 条件运算符 ? :，可以用来替代 if...else 语句。它的一般形式如下：
Exp1 ? Exp2 : Exp3;
其中，Exp1、Exp2 和 Exp3 是表达式。请注意，冒号的使用和位置。
? 表达式的值是由 Exp1 决定的。如果 Exp1 为真，则计算 Exp2 的值，结果即为整个 ? 表达式的值。如果 Exp1 为假，则计算 Exp3 的值，结果即为整个 ? 表达式的值。



C if 语句
 
一个 if 语句 由一个布尔表达式后跟一个或多个语句组成。
语法

C 语言中 if 语句的语法：
if(boolean_expression)
{
   // 如果布尔表达式为真将执行的语句 
}
如果布尔表达式为 true，则 if 语句内的代码块将被执行。如果布尔表达式为 false，则 if 语句结束后的第一组代码（闭括号后）将被执行。
C 语言把任何非零和非空的值假定为 true，把零或 null 假定为 false。
流程图

C 中的 if 语句
实例
*//*
#include <stdio.h>
 
int main ()
{
   // 局部变量定义 
   int a = 30;
 
   //使用 if 语句检查布尔条件 
   if( a < 20 )
   {
       //如果条件为真，则输出下面的语句 
       printf("a 小于 20\n" );
   }
   else
   {
       printf("a不等于b \n"); 
   }
   printf("a 的值是 %d\n", a);
 
   return 0;
}/*
当上面的代码被编译和执行时，它会产生下列结果：
a 小于 20
a 的值是 10
*/
/*
#include <stdio.h>
 
int main ()
{
   //局部变量定义 
   int a = 100;
 
   //检查布尔条件 
   if( a == 10 )
   {
       // 如果 if 条件为真，则输出下面的语句
       printf("a 的值是 10\n" );
   }
   else if( a == 20 )
   {
       //如果 else if 条件为真，则输出下面的语句 
       printf("a 的值是 20\n" );
   }
   else if( a == 30 )
   {
       //如果 else if 条件为真，则输出下面的语句 
       printf("a 的值是 30\n" );
   }
   else
   {
       // 如果上面条件都不为真，则输出下面的语句
       printf("没有匹配的值\n" );
   }
   printf("a 的准确值是 %d\n", a );
 
   return 0;
}
*/
/*
#include <stdio.h>
 
int main ()
{
   //局部变量定义 
   char grade = 'B';

   switch(grade)
   {
   case 'A' :
      printf("很棒！\n" );
      break;
   case 'B' :
   case 'C' :
      printf("做得好\n" );
      break;
   case 'D' :
      printf("您通过了\n" );
      break;
   case 'F' :
      printf("最好再试一下\n" );
      break;
   default :
      printf("无效的成绩\n" );
   }
   printf("您的成绩是 %c\n", grade );
 
   return 0;
}

*/
/*
#include <stdio.h>
int main ()
{
   //*局部变量定义 
   int a = 100;
   int b = 200;
 
   //*检查布尔条件 
   if( a == 100 )
   {
       //如果条件为真，则检查下面的条件 
             if( b == 200 )
       {
          //*如果条件为真，则输出下面的语句 
          printf("a 的值是 100，且 b 的值是 200\n" );
       }
   }
   printf("a 的准确值是 %d\n", a );
   printf("b 的准确值是 %d\n", b );
 
   return 0;
}
*/
/*
当上面的代码被编译和执行时，它会产生下列结果：
a 的值是 100，且 b 的值是 200
a 的准确值是 100
b 的准确值是 200
 */
 
 /*
 C switch 语句

C 判断 C 判断
一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查。
语法

C 语言中 switch 语句的语法：
switch(expression){
    case constant-expression  :
       statement(s);
       break; //可选的
    case constant-expression  :
       statement(s);
       break; //可选的
  
    //您可以有任意数量的 case 语句
    default : //可选的 
       statement(s);
}
switch 语句必须遵循下面的规则：
switch 语句中的 expression 必须是一个整型或枚举类型，或者是一个 class 类型，其中 class 有一个单一的转换函数将其转换为整型或枚举类型。
在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。
case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且必须是一个常量或字面量。
当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。
不是每一个 case 都需要包含 break。如果 case 语句不包含 break，控制流将会 继续 后续的 case，直到遇到 break 为止。
一个 switch 语句可以有一个可选的 default case，出现在 switch 的结尾。default case 可用于在上面所有 case 都不为真时执行一个任务。default case 中的 break 语句不是必需的。
流程图

C 中的 switch 语句
实例
*/
/*
#include <stdio.h>
 
int main ()

{
   //局部变量定义  
   int number ; 
   printf("输入您的成绩：");
   scanf("%d",&number); 
   switch(number)
   {
       
   case 100 :
       printf("很棒！\n" );
       break;
      
   case 90 :
           printf("还可以！\n" );
      
      break;
       
   case 80 :
       
      printf("做得好\n" );
      
      break;
      
   case 60 :
       
      printf("您通过了\n" );
      
      break;
      
   case 50 :
       
      printf("最好再试一下\n" );
      
      break;
       
   default :
       
      printf("垃圾成绩\n" );
      
   }
   
//   printf("您的成绩是 %d\n", number );
   
   return 0;
}
*/
/*
当上面的代码被编译和执行时，它会产生下列结果：
做得好
您的成绩是 B
*/
//#####################################################
/*
C do...while 循环

C 循环 C 循环
不像 for 和 while 循环，它们是在循环头部测试循环条件。在 C 语言中，do...while 循环是在循环的尾部检查它的条件。
do...while 循环与 while 循环类似，但是 do...while 循环会确保至少执行一次循环。
语法

C 语言中 do...while 循环的语法：
do
{
   statement(s);

}while( condition );
请注意，条件表达式出现在循环的尾部，所以循环中的 statement(s) 会在条件被测试之前至少执行一次。
如果条件为真，控制流会跳转回上面的 do，然后重新执行循环中的 statement(s)。这个过程会不断重复，直到给定条件变为假为止。
*/
/*
#include<stdio.h>
int main()
{
    //局部变量定义
    int a=10;
    //do 循环执行
    do
    {
        printf("a的值：%d\n",a);
        a++;
    } while(a<20);
    return 0;
} 
*/
/*
C 嵌套循环

C 循环 C 循环
C 语言允许在一个循环内使用另一个循环，下面演示几个实例来说明这个概念。
语法

C 语言中 嵌套 for 循环 语句的语法：
for ( init; condition; increment )
{
   for ( init; condition; increment )
   {
      statement(s);
   }
   statement(s);
}
C 语言中 嵌套 while 循环 语句的语法：
while(condition)
{
   while(condition)
   {
      statement(s);
   }
   statement(s);
}
C 语言中 嵌套 do...while 循环 语句的语法：
do
{
   statement(s);
   do
   {
      statement(s);
   }while( condition );

}while( condition );
关于嵌套循环有一点值得注意，您可以在任何类型的循环内嵌套其他任何类型的循环。比如，一个 for 循环可以嵌套在一个 while 循环内，反之亦然。
*/
/*
#include<stdio.h> 
int main()
{
    
    int i;
    float j;
    /*
    for(i=2;i<100;i++)
        {for (j=2;j<=(i/j);j++)
            if (!(i%j))
                break;
            if (j>(i/j))
                printf("%d是质数\n",i);
        } 
        return 0;*/ /*
        printf("张黄就\t是帅\n ");
        scanf("%d %f",&i,&j);
        printf("%d %.1f",i,j);
        
        
} */
/*
int 整数       %d
float 浮点数   %f
char 字符串    %c
double         %m.nf
\n 
\t 
*/

/*
#include <stdio.h>
int main()
{
    int i,j;
    for (i=100;i<200;i++)
    {
        for (j=100;j<=(i/j);j++)
            if (!(i%j))
                break;
            if (j>(i/j))
                printf("%d是质数\n",i);
                
    }
    return 0;
}
*//*
#include<stdio.h>
#include<math.h>
int main()
{
    int m,i,j,sum=0;
    for (m=101;m<300;++m)
    {
        for (i=2;i<m;++i)
        if (m%i==0) break;
        if (i>m)
        sum+=m;
    }
    printf("%d",sum);
} 

*/



/*
#include <stdio.h>

// 变量声明
extern int a, b;
extern int c;
extern float f;

int main ()
{
  //变量定义 
  int a, b;
  int c;
  float f;
 
  // 实际初始化
  a = 10.00;
  b = 20;
  
  c = a + b;
  printf("value of c : %d \n", c);

  f = 70.0/3.0;
  printf("value of f : %f \n", f);
 
  return 0;
}

*//*
#include <stdio.h>

// 变量声明

int main ()
{
  //变量定义 
  int  number;
  printf("杨双炎= \n");
  scanf("%d",&y);
//  if (x>=0)
//      y=x+5;
//  else
//      y=-x+5;
    printf("杨双炎=\n%d    ",y);
      return 0; 
  }

*/
//#include <stdio.h>
//
//// 变量声明
//
//int main ()
//{
//  //变量定义 
////  int x;
//  float y;
////  double z;
//  printf("请蒋哥您输入x= \n"); 
//  scanf("%f",&y);
//  printf("蒋哥您要的数字是 %f",y); 
//  return 0; 
//} 
/*
#include <stdio.h>
 
int main ()

{
   //局部变量定义  
   int number ; 
   printf("输入您的成绩：");
   scanf("%d",&number); 
   if (number>0)
        printf("你123 =%d" ,number);
    else
        if (number>-2)
            printf("456");
        
        else
            printf("789");

} */
/*     
#include <stdio.h>
 
int main ()
{
    int i,j;
    for( i=1;i<=9;i=i+1)
    {
        for (j=1;j<=i;j++)
        printf("%d x %d = %d ",i,j,i*j);
        printf("\n"); 
        
    }
//    printf("%d\n",i,j);
}
*/
//#include <stdio.h>
// 
//int main ()
//{
//    int S=0 ,i=1;
//    while(i<=100)
//    {
//        S=S+i;
//        i++;
//    } 
//     
//    printf("S=%d",S);
//    return 0;
//}
//


//
//#include <stdio.h>  头文件   
// 
//int mult (int n)     函数 
//{
//    static int init =1;    函数体 
//    return init*=n; 
//}
//main()    主函数  
//{
//    int n;
//    for(n=1;n<=5;n++)
//        printf("%d,",mult(n)); 
//} 

//#include<stdio.h>
//int main()
//{
//    float y,x,a;
//    for (y=1.5f;y>-1.5f;y-=0.1f)
//    {
//        for (x=-1.5f;x<1.5f;x+=0.05f)
//        {
//            a=x*x+y*y-1;
//            put char(a*a*a-x*x*y*y*y<=0.0f?"*":"");
//        } 
//        put char("\n");
//    } 
//    return 0;
//} 
// 


//#include<stdio.h>
//int main()
//{
//    float y, x, a;
//    for(y=1.5f;y>-1.5f;y-=0.1f)
//    {
//        for (x=-1.5f;x<1.5f;x+=0.05f)
//        {
//            a=x*x+y*y-1;
//            putchar(a*a*a-x*x*y*y*y<=0.0f?'*':' ');
//        }
//        putchar('\n');
//    }
//return 0;
//}