“教小白精通编程”系列之“C语言教程” （版权所有，不得转载，擅自抄袭转载将承担法律责任）
什么是程序？程序就是对数据进行处理的指令集合，即对数据进行运算，数据有文本、图像、视频、声音等，但不管怎么复杂的数据，我们总能用一些基本的数据类型表示，比如不管数据如何复杂，最后都可以表示成机器可以识别的二进制，即最终都能用0和1表示。正如一篇英文小说，不管如何宏大，最都是由一些单词，最终是由26个英文字母表示的，字母就是最基本的数据类型。同样，任一个实数，都可以用一串0到9的数字和小数点构成。
早期的机器语言程序完全由代表0和1的穿孔纸表示数据和指令，而高级编程语言提供了更方便的表示数据和指令的语法规则，如同我们不同语言有不同的语法词汇规则一样。借助于编译器，高级语言编写的程序能够被转换成机器语言指令，而用高级编程语言编写程序不但可读性好且编程效率高。比如高级语言中可以直接用”2+3”表示2和3的加法运算。
printf 函数
假设我们要编写一个已知半径求圆的面积的程序，可以这样写
//计算半径是2.5的圆的面积
int main(){
3.1415*2.5*2.5; //其中的*表示“乘法运算符”
return 0;
}
但这个程序没有任何用处，因为程序执行的结果我们看不到，如何输出程序的结果呢？
#include <stdio.h>
int main(){
printf(3.1415*2.5*2.5); //编译出错！因为prtinf函数的规范不允许直接输出一个实数或整数
return 0;
}
能不能写成如下形式？
#include <stdio.h>
int main(){
printf("3.1415*2.5*2.5");
return 0;
}
编译运行这个程序，输出的结果是
3.1415*2.5*2.5
并不能输出圆的面积，这是因为双引号”“之间的被认为是一串字符，而并没有真正地计算。
如何正确地输出圆的面积呢？需要我们查询标准输出函数printf的函数规范。
printf函数格式大致如下：
printf( "格式串", 输出项);
即这个函数的第一个形式参数是一个所谓的双引号括起来的格式串,printf函数会根据格式串中的字符做不同的动作，比如普通字符如字母就直接输出，而遇到转义字符就执行特定的动作，比如遇到字符’\n’就换一行，遇到%开头的格式转换字符,会输出格式串后面的对应的所谓输出项。
#include <stdio.h>
int main(){
printf("圆的面积是%f",3.1415*2.5*2.5); //输出遇到%f就输出后面对应的3.1415*2.5*2.5
return 0;
}
编译运行这个程序，将输出正确的元的面积
我们可以修改程序，使得输出2个
#include <stdio.h>
int main(){
printf("半径是%f的圆的面积是%f",2.5，3.1415*2.5*2.5); //第1个%f 对应第2个输出项2.5，第2个%f 对应第2个输出项3.1415*2.5*2.5
return 0;
}
总结： pritnf的第一个形参参数即格式串，可包含下列三种字符类型：
1）一般字符，将会直接输出
2）转义字符，如\t、\n 等有特定含义
3）格式转换字符 . 如 %f 、%d. 定义后面输出项（variables）的类型，而variables则是一些要按照这格式输出的变量。如：
%.nd integer (可选的n说明输出整数数字占据的列数)
%m.nf float or double (可选的m = 占据的列数,
n = 精度的位数)
%ns string (可选的 n = 占据的列数s)
%c character(字符)
\n \t 换行或制表符
\g 终端上响铃
请修改一下%f，看看运行结果是什么样的？
#include <stdio.h>
int main(){
printf("半径是%10.4f的圆的面积是%10.4f",2.5，3.1415*2.5*2.5); //第1个%f 对应第2个输出项2.5，第2个%f 对应第2个输出项3.1415*2.5*2.5
return 0;
}
变量
上面的程序只能计算半径是2.5的圆的面积，假如我们需要一个程序，让运行它的用户输入一个半径，然后这个程序输出对应半径的面积，怎么办？
这就需要程序能提供用户输入半径的方法，我们可以用C的标准输入函数scanf完成这个工作，其函数规范是：
scanf( "格式串", 输入项);
其格式串类似于printf函数的格式串，但输入项必须是一个内存块的地址，即输入的数据放到这个地址对应的内存块中。
怎么告诉程序给我们分配一块内存块存放比如圆的半径呢？ 可以如下定义一个变量：
float radius; //定义了一个名字叫做radius的数据类型是float的变量
当我们定义了这个叫做radius的数据类型是float的变量,我们就得到了一块可以存放数据类型是float（即所谓的“单精度浮点实数类型”）的内存块。这个内存块的大小正好可以放一个float类型的实数。
我们还需要一个叫做”取地址运算符&“的运算符作用于这个变量radius，即通过”&radius”可以得到变量radius的内存块的起始地址。
现在，我们可以写出如下的程序:
#include <stdio.h>
int main(){
float radius; ////定义了一个数据类型是float的变量radius
scanf("%f",&radius) ; // 等待用户从键盘输入数据到地址为&radius的float内存块里。
printf("半径是%10.4f的圆的面积是%10.4f",radius，3.1415*radius*radius);
return 0;
}
程序中定义了一个float类型的变量radius,然后一同scanf从键盘等待用户输入一个实数，最后pritnf圆的面积结果(3.1415radiusradius).
变量定义的一般格式是:
数据类型 变量名；
数据类型 变量名 = 初始值；
数据类型 变量名1 {= 初始值1},变量名2 {= 初始值2},变量名3 {= 初始值2}；
例如
int a,b,c; //定义了int整数类型的3个变量a,b,c，都没有给初始值
double PI = 3.1415; //定义了double类型的变量,doule是双精度浮点实数类型
double radius = 2.5, area;
说穿了，变量就是内存块的名字。C语言中变量都必须说明其数据类型，因为只有知道数据类型，编译器才知道给这个变量分配多大的内存，比如int整数类型变量占4个字节内存，而double类型变量占8个字节内存。变量的类型同时也规定了对这种类型的变量能进行什么样的运算。比如不能用“取模运算%”去得到2个实数的相除的余数。
#include <stdio.h>
int main(){
int a = 3,b = 4;
float x = 3.5,y = 4.5;
printf("%d",a%b); //a除以b的余数
printf("%f",x%y); //错：不能对实数x和y求余数
return 0;
}
此外，变量的类型还定义了这种类型变量的取值范围，比如同样是整数类型,int表示的整数的范围和long（长整型）表示的整数范围是不一样的，同样是实数类型float和double(双精度浮点实数)表示的实数范围也是不一样的
表达式：用运算符对运算数进行运算
运算符对运算数进行运算构成了表达式，运算符既包括变量，也包括“文字量”，所谓“文字量”就是其值直接写出来的量，如字符串”hello world”、3.14、2.5等。
最简单的表达式是只含一个运算数的表达式，如”hello world”、3.14、2.5、radius等.同样3.1415*2.5*2.5和3.1415*radius*radius也是表达式。
因此表达式是可以嵌套的，即小的表达式题哦能提供过运算符运算就构成了更大的表达式。如3.1415*radius*radius是由表达式3.1415和radius通过乘法运算符*构成表达式3.1415*radius,然后这个表达式和radius通过乘法运算符*构成表达式3.1415*radius*radius。
宏定义 #define
假如我们在一个程序中需要多次计算圆的面积，比如
#include <stdio.h>
int main(){
float radius,area; //radius表示半径、area表示面接
scanf("%f",&radius) ;
area = 3.1415*radius*radius;
printf("半径是%10.4f的圆的面积是%10.4f",radius，area);
scanf("%f",&radius) ;
area = 3.1415*radius*radius;
printf("半径是%10.4f的圆的面积是%10.4f",radius，area);
scanf("%f",&radius) ;
area = 3.1415*radius*radius;
printf("半径是%10.4f的圆的面积是%10.4f",radius，area);
return 0;
}
后来我们觉得PI的值需要修改成精度不一样的比如3.1415926，我们可以在程序中找到所有用到PI的地方，一个一个替换掉
#include <stdio.h>
int main(){
float radius,area; //radius表示半径、area表示面接
scanf("%f",&radius) ;
area = 3.1415926*radius*radius;
printf("半径是%10.4f的圆的面积是%10.4f",radius，area);
scanf("%f",&radius) ;
area = 3.1415926*radius*radius;
printf("半径是%10.4f的圆的面积是%10.4f",radius，area);
scanf("%f",&radius) ;
area = 3.1415926*radius*radius;
printf("半径是%10.4f的圆的面积是%10.4f",radius，area);
return 0;
}
然后，如果一个大程序包含很多文件，要在所有这些文件中一个个搜索、替换，难免会出错！ 有什么更好的方法呢？
方法是我们只在一个地方给这个不会变化的圆周率起一个名字，比如叫做PI，其他地方只要用这个名字PI就可以了。 这就用到另外一个叫做宏定义#define的预处理命令，即用#define给我们的圆周率的值比如3.14起一个名字。
#define PI 3.1415
程序可以修改为
#include <stdio.h>
#define PI 3.1415926
int main(){
float radius,area; //radius表示半径、area表示面接
scanf("%f",&radius) ;
area = PI*radius*radius;
printf("半径是%10.4f的圆的面积是%10.4f",radius，area);
scanf("%f",&radius) ;
area =PI*radius*radius;
printf("半径是%10.4f的圆的面积是%10.4f",radius，area);
scanf("%f",&radius) ;
area = PI*radius*radius;
printf("半径是%10.4f的圆的面积是%10.4f",radius，area);
return 0;
}
将来如果要修改圆周率，只要在#define处修改PI名字对应的值就可以了。极大地方便了程序员。
在编译程序时，预处理器会完成将程序中所有PI出现的地方用其实际数值替换掉，然后再进行编译。
const关键字
我们可以用const关键字定义一个不会变化的量，称为常量。如
int main(){
const int a = 2; //a是一个const int类型的常量
a = 4; //错：const类型的变量是不能被修改的！
}
建议 ：尽可能用const代替#define定义的宏常量。因此我们可以将圆周率定义成const类型的常量
```c
#include <stdio.h>
const float PI = 3.1415926; //注意：这是C语句，必须分号结尾，而#define是预处理命令，不能有分号
int main(){
float radius,area; //radius表示半径、area表示面接
scanf("%f",&radius) ;
area = PI*radius*radius;
printf("半径是%10.4f的圆的面积是%10.4f",radius，area);
return ;
}
练习
- 下列标识符哪些是合法的变量名？
- 编写程序，从键盘输入2个整数，输出它们的和、差、积、商、余数的值
@ohd *zara a2bc move_name a_123 myname50 _temp j a23b9 retVal 51_name -
写一个程序计算体积： cube(立方体), sphere(球), cone(圆锥).
立方体体积 = side3
球体体积 = (4/3) * pi * radius3
锥体体积 = pi * radius2 * (height/3)
程序框架如下
#include<stdio.h>
int main(){
float cubeSide，sphereRadius， coneRadius ，coneHeigh， //图形的参数
volCube, volSphere, volCone = 0; //体积变量
return 0;
}
基本数据类型
C语言本身定义了一些数据类型如int、char、double，这些C语言自带的数据类型叫做 内在类型(built-in类型) 。今后我们会看到C语言也允许程序员定义自己的所谓”用户定义类型“。
内在类型分为：基本数据类型和派生类型。
基本数据类型主要: 整数类型(Integer types)、浮点数类型(Floating type)、字符类型(Character type).
字符类型:
char: 字符类型，如'A'
整型：
short: 短整型,如3s
int: 整型
long: 长整型，如3L
long long: 长长整型,如3LL
浮点类型包括
float 单精度实数，如3.14f
double 双精度实数，如3.14, -3.14e3
long double 长双精度实数，如3.14L
我们看到一个文字量后面用后缀如’L’表示这是一个长整型long而不是整型int，而s表示一个短整型。 上述类型结合signed 和unsigned，又派生出更多的基本类型。如
unsigned int positiveInteger; //unsigned int表示无符号整型
总结： 每个变量都具有一定的类型，类型规定了一个变量在内存里占用多大空间，也规定了对这种类型的变量能进行什么样的操作（运算），当然也规定了该类型变量的取值范围。下面是一些常用类型：
int -> integer variable(整型变量，表示整数，一般占4个字节)
short -> short integer (短整型，一般占2个字节)
long -> long integer (长整型，一般占6或8个字节)
float -> single precision real (floating point) variable(单精度实数（浮点类型），一般占4个字节)
double -> double precision real (floating point) variable (双精度实数（浮点类型），一般占8个字节)
char -> character variable (single byte) (字符型（单字节)）
更多数据类型的信息可以参考C_data_types
在头文件limits.h中每种数据类型对应的数值的最大最小值都有对应的宏常量。比如
| Type | MIN | MAX |
|---|---|---|
| char | CHAR_MIN | CHAR_MAX |
| short | SHORT_MIN | SHORT_MAX |
| int | INT_MIN | INT_MAX |
| long | LONG_MIN | LONG_MAX |
| long long | LLONG_MIN | LLONG_MAX |
| float | FLT_MIN | FLT_MAX |
| double | DBL_MIN | DBL_MAX |
| long double | LDBL_MIN | LDBL_MAX |
可以用下列程序检测你的操作系统上的每种数据类型的范围：
// Finding the limits
#include <stdio.h> // For command line input and output
#include <limits.h> // For limits on integer types
#include <float.h> // For limits on floating-point types
int main(void)
{
printf("Variables of type char store values from %d to %d\n", CHAR_MIN, CHAR_MAX);
printf("Variables of type unsigned char store values from 0 to %u\n", UCHAR_MAX);
printf("Variables of type short store values from %d to %d\n", SHRT_MIN, SHRT_MAX);
printf("Variables of type unsigned short store values from 0 to %u\n", USHRT_MAX);
printf("Variables of type int store values from %d to %d\n", INT_MIN, INT_MAX);
printf("Variables of type unsigned int store values from 0 to %u\n", UINT_MAX);
printf("Variables of type long store values from %ld to %ld\n", LONG_MIN, LONG_MAX);
printf("Variables of type unsigned long store values from 0 to %lu\n", ULONG_MAX);
printf("Variables of type long long store values from %lld to %lld\n", LLONG_MIN, LLONG_MAX);
printf("Variables of type unsigned long long store values from 0 to %llu\n", ULLONG_MAX);
printf("\nThe size of the smallest positive non-zero value of type float is %.3e\n", FLT_MIN);
printf("The size of the largest value of type float is %.3e\n", FLT_MAX);
printf("The size of the smallest non-zero value of type double is %.3e\n", DBL_MIN);
printf("The size of the largest value of type double is %.3e\n", DBL_MAX);
printf("The size of the smallest non-zero value of type long double is %.3Le\n", LDBL_MIN);
printf("The size of the largest value of type long double is %.3Le\n", LDBL_MAX);
printf("\n Variables of type float provide %u decimal digits precision. \n", FLT_DIG);
printf("Variables of type double provide %u decimal digits precision. \n", DBL_DIG);
printf("Variables of type long double provide %u decimal digits precision. \n",LDBL_DIG);
return 0;
}
你会得到类似下面的结果
Variables of type char store values from -128 to 127
Variables of type unsigned char store values from 0 to 255
Variables of type short store values from -32768 to 32767
Variables of type unsigned short store values from 0 to 65535
Variables of type int store values from -2147483648 to 2147483647
Variables of type unsigned int store values from 0 to 4294967295
Variables of type long store values from -2147483648 to 2147483647
Variables of type unsigned long store values from 0 to 4294967295
Variables of type long long store values from -9223372036854775808 to 9223372036854775807
Variables of type unsigned long long store values from 0 to 18446744073709551615
The size of the smallest positive non-zero value of type float is 1.175e-038
The size of the largest value of type float is 3.403e+038
The size of the smallest non-zero value of type double is 2.225e-308
The size of the largest value of type double is 1.798e+308
The size of the smallest non-zero value of type long double is 3.362e-4932
The size of the largest value of type long double is 1.190e+4932
Variables of type float provide 6 decimal digits precision.
Variables of type double provide 15 decimal digits precision.
Variables of type long double provide 18 decimal digits precision.
sizeof
我们可以用这个运算符得到你的操作系统上的数据类型占据的内存大小. 其使用格式
size_t size = sizeof(long long);
int var;
size_t size = sizeof(var);
即其参数可以是类型名也可以是一个具体的变量名。返回的是表示占用的字节个数的值，返回类型size_t定义在头文件stddef.h中，是C语言的某种整数类型，取决于不同的C语言实现。例如可能是
typedef unsigned int size_t;
这里关键字typedef表示定义一个新的数据类型size_t,就是类型unsigned int。也就是给已有类型unsigned int起了一个新的名字叫做size_t。
正如我们给一个人起一个外号或别名一样，它们和原来的名字表示的是同一个类型！ 例如，我们可以用下面的程序:
// Program Finding the size of a type
#include <stdio.h>
int main(void)
{
printf("Variables of type char occupy %u bytes\n", sizeof(char));
printf("Variables of type short occupy %u bytes\n", sizeof(short));
printf("Variables of type int occupy %u bytes\n", sizeof(int));
printf("Variables of type long occupy %u bytes\n", sizeof(long));
printf("Variables of type long long occupy %u bytes\n", sizeof(long long));
printf("Variables of type float occupy %u bytes\n", sizeof(float));
printf("Variables of type double occupy %u bytes\n", sizeof(double));
printf("Variables of type long double occupy %u bytes\n", sizeof(long double));
return 0;
}
检测系统上不同类型占用内存的大小,结果类似于
Variables of type char occupy 1 bytes
Variables of type short occupy 2 bytes
Variables of type int occupy 4 bytes
Variables of type long occupy 4 bytes
Variables of type long long occupy 8 bytes
Variables of type float occupy 4 bytes
Variables of type double occupy 8 bytes
Variables of type long double occupy 12 bytes
类型转换
不同类型的数据进行运算时，需要转换成同一种类型才能进行运算。
隐含类型转换： 当一个运算符对不同类型数据进行运算时，编译器会隐含地将精度小的类型转换为精度高的类型，比如
double x = 2.5;
x*25; //int类型的值25被转换成double再和x相乘
而在赋值运算符=时，会将右边的类型转换为左边的类型，同样在初始化时，也会将初始值的类型转换成变量的类型
int a = 5,b = 4.3; //4.3从double转换为int再对b初始化
double x;
x = a; //将a隐含从int类型转换为double类型
a = x+b; //x+b按照double类型运算，结果从double又转换为int，再给a赋值
强制类型转换 有时需要我们明白的进行类型转换。即强制类型转换， 如下将一个表达式的值转换成类型名对应的类型。
(类型名)表达式
或
类型名(表达式)
比如：
double result = 0.0;
int a = 5;
int b = 8;
result = (a + b)/2 - (a + b)/(a*a + b*b);
其中(a + b)/2 即(5+8)/2结果为整数6,而(a + b)/(a*a + b*b)即(5+8)/(5*5+8*8) = 13/89 = 0
因此，最后得到一个整数结果6，这个6会被隐含转为double类型的值6.0。
如果我们希望得到正确的double型结果，可以使用强制类型转换，程序可以这样写：
double result = 0.0;
int a = 5;
int b = 8;
result = (double)(a + b)/2 - (a + b)/(double)(a*a + b*b);
混合int和unsigned类型时，会用同样的“取模法”(余数法)将负整数转化为unsigned.
int main(){
unsigned u = 0;
u = u-1; //如果unsigned是32位整数: [0, 4294967295]
// (-1+4294967296) % 4294967296
printf("%u\n",u);
int i = -42;
printf("%u\n",i+1); // 输出 -84
printf("%u\n", u + i); // 如果是32位整数，则输出4294967264
// (-42+4294967296)%4294967296 = 4294967254
}
int main(){
int a = -1,b = -1;
unsigned c = 1;
printf("%u\n%u\n", a*b,a*c);
}
练习
- 理解并运行下列程序，看看结果是否符合你的预期，为什么？
int main(){ unsigned u = 10, u2 = 42; printf(“%u\n”, u2 - u ); printf(“%u\n”, u - u2);
int i = 10, i2 = 42; printf(“%d\n”, i2 - i); printf(“%d\n”, i - i2);
printf(“%u\n”, i - u); printf(“%u\n”, u - i);
// for (unsigned u = 10; u >= 0; –u) // std::cout « u « std::endl;
return 0; }
声明与定义
声明就是说存在这个名字的“类型、对象（变量）和函数”，但没有完整的信息
定义是这个名字“类型、对象（变量）和函数”完整的描述
变量(对象)的定义不但说明这个对象的类型和名字还会分配一块内存， 而对象的声明则仅仅说明其类型和名字，并不分配内存
变量声明：说明变量类型和变量名
变量定义：除“说明变量类型和变量名外，还会分配内存块，并可能提供初始值。
变量声明，需要用关键字extern 开头且不能初始化。
extern int i; //说明存在叫作i的int型变量，但声明并没有为它分配内存
int j; //定义了叫作j的int型变量，并为它分配了一块内存
extern double r = 2.5;
// 定义了叫作r的double型变量，并为它分配了一块内存
//其初始化是2.5。包含初始值的尽管前面有extern，也属于变量定义！
当然“变量的定义”也包含了“变量的声明”，反之不然！
“变量可以声明多次，但只能定义1次”，如：
extern int a;
extern int a;
int main(){
extern int a;
extern int a;
int b;
return 0;
}
可以将变量的声明和定义放在不同文件里，一般的声明放在所谓的头文件中， 如下面的头文件util.h中包含了变量a的声明
//util.h
extern int a;
//...
而变量a的定义在util.c文件中：
//util.c
int a = 0;
其他程序文件如test.cpp如果需要用到变量a，可以包含(#include)这个头文件
//test.c
#include <stdio.h> //头文件用<>表示只在系统路径查找是否存在这个文件
#include "util.h" //头文件用" "表示会先在当前路径查找，然后在系统路径查找是否存在这个文件
int main() {
a = 3*5;
printf("%d",a);
}
外部变量(全局变量)与局部变量
定义在某个函数内部的变量叫做“局部变量”或“内部变量”，反之，称为“全局变量”或“外部变量”
对于基本类型的变量： 定义外部变量如果没有给初始值，则默认为0.而对于内部变量，其值是不确定的。
复合 赋值运算符
赋值运算符=可以和算术运算符如+、-、*、/、%等结合起来使用.b比如
a+=b; //相当于a = a+b;
a*=b; //相当于a = a*b;
a /= b + 1; //相当于a = a*(b+1);
...
a%=b; //相当于a = a%b;
数学函数
前面我们提高math.h定义了很多数学函数。比如：
| function | operation |
|---|---|
| floor(x) | Returns the largest integer that isn’t greater than x as type double |
| ceil(x) | Returns the smallest integer that isn’t less than x as type double |
| fabs(x) | Returns the absolute value of x |
| log(x) | Returns the natural logarithm (base e) of x |
| log10(x) | Returns the logarithm to base 10 of x |
| exp(x) | Returns the value of ex |
| sqrt(x) | Returns the square root of x |
| pow(x, y) | Returns the value xy |
| sin(x) | Sine of x expressed in radians |
| cos(x) | Cosine of x |
| tan(x) | Tangent of x |
练习
- 一元二次方程求根：从键盘输入方程的系数(假设判别式>=0)，输出其方程的2个根。
注：求实数的平方根可以用math.h中的sqrt函数来求，如sqrt(5.6).
下面的内容要移到循环一节中讲解
例题 下面的程序计算 ０ 到３６０度之间的 sin 函数值 .
说明： 其中数据计算如sin的函数定义在头文件math.h中。
/* -----sine 函数表----
下面的程序计算 ０ 到３６０度之间的 sin 函数值
说明： 其中数据计算如sin的函数定义在头文件math.h中。
*/
#include < stdio.h>
#include < math.h>
#define PI 3.1415926
void main()
{
int angle_degree; /*int 是整型，说明变量angle_degree是一个整数*/
double angle_radian, pi, value; /*double 是双精度实数类型，说明变量angle_radian, pi, value是实数*/
/* 打印表头 */
printf ("\nCompute a table of the sine function\n\n");
printf ( " angle Sine \n" );
angle_degree=0; /* 初始化角度值为0 */
/* scan over angle */
while ( angle_degree <= 360 ) /* 循环执行循环体（while程序块）直到angle_degree > 360 */
{
angle_radian = pi * angle_degree/180.0 ;
value = sin(angle_radian);
printf ( " %3d %f \n ", angle_degree, value );
angle_degree = angle_degree + 10; /* 增量 */
}
}
编译该程序：
gcc sine.c -lm
执行该程序：
. /a.out
说明：
1) /* 和 */ 之间的文字都属程序注释，不是程序语句，仅仅是为了说明这个程序，帮助自己对自己做的工作做一下注释或帮助别人理解程序的代码。
2） 变量的类型
一个程序的数据分为变量和常量。其中主要是变量。
每个变量必须说明其类型.
其定义格式是：
数据类型名 变量名;
数据类型名 变量1名,变量2名,...变量k名;
如程序中的：
/*int 是整型，说明变量angle_degree是一个整数*/
int angle_degree;
/*double 是双精度实数类型，说明变量angle_radian, pi, value是实数*/
double angle_radian, pi, value;
再如：
/*也可以在定义变量时用一个初始化式（如这里的=3.14）给变量一个初始值*/
double angle_radian, pi=3.14,value;
每个变量都具有一定的类型，类型规定了一个变量在内存里占用多大空间，也规定了对这种类型的变量能进行什么样的操作（运算），当然也规定了该类型变量的取值范围。C程序有下面的一些常用类型：
int -> integer variable(整型变量，表示整数，一般占4个字节)
short -> short integer (短整型，一般占2个字节)
long -> long integer (长整型，一般占6或8个字节)
float -> single precision real (floating point) variable(单精度实数（浮点类型），一般占4个字节)
double -> double precision real (floating point) variable (双精度实数（浮点类型），一般占8个字节)
char -> character variable (single byte) (字符型（单字节)）
可以看到，变量名是可以任意定义的，可以是一个字母或多个字母、数字、下划线等，但第一个字符只能是字母或下划线。如
double Pi;
float _angle;
int 3angle; /*错，第一个字符不是字母或下划线*/
int if;
/*错：变量名不能是C语言的关键字，如if、int、include、return、...*/
变量名要具有可读性，以方便阅读理解这个程序，有的编译器可能限制变量名的最大长度。
3) printf 函数 可以打印 int, float,字符串等变量或常量…
其函数格式大致如下：
printf( "format", variables );
其中”format”称为格式串，可包含下列三种字符类型：
1）一般字符，将会直接输出
2）ASCII 控制字符，如\t、\n 等有特定含义
3）格式转换字符 . 如 %f 、%d. 定义后面输出项（variables）的类型，而variables则是一些要按照这格式输出的变量。如：
%.nd integer (可选的n说明输出整数数字占据的列数)
%m.nf float or double (可选的m = 占据的列数,
n = 精度的位数)
%ns string (可选的 n = 占据的列数s)
%c character(字符)
\n \t 换行或制表符
\g 终端上响铃
4) 和printf向屏幕输出数据相对的是从键盘输入数据的scanf函数，它们都是C语言的标准库函数（即已经实现好的函数，我们只要调用就行）。例如：
#include <stdio.h> /* stdio.h 中定义了输出输出相关的函数 */
void main(){
int a;
float b;
scanf(“%d %f”, &a, &b); /* 从键盘输入一个整数和一个实数 */
printf(“%d %f”, a, b); /* 向屏幕输出一个整数和一个实数*/
}
注意: scanf传递的必须是要输入的输入项的地址，用”取地址运算符&”可以得到一个变量的地址，如上面的”&a” 和”&b”分别将取得a,b两个变量的地址并传给scanf函数.
支付宝打赏
微信打赏
您的打赏是对我最大的鼓励！
