【C语言】超详解，让你C语言成功入门（一）

一、简单了解C语言和程序设计

了解什么是计算机程序和计算机语言

计算机程序

程序就是一组计算机能识别和执行的指令，每一条指令使计算机执行特定的操作。一个特定的指令序列用来完成一定的功能。为了使计算机能实现各种功能，往往需要成百上千万个程序。

总之，计算机的一切操作都是由程序控制的，离开程序，计算机将毫无用处。所以，计算机的本质就是程序的机器，程序和指令是计算机系统中最基本的概念。

计算机语言

计算机语言即计算机能识别的语言，粗俗点说，就是计算机能看懂的。

计算机语言经历了以下几个发展阶段：

机器语言 计算机工作基于二进制，从根本上说，计算机只能识别和接受由0和1组成的指令。计算机发展初期，一般计算机的指令长度为16，即16个二进制数（0或1）组成的一条指令，如：0010111110101101

这种能直接识别和接受的二进制代码称为机器指令 ，而机器指令的集合就是机器语言。

缺点：难学，难用，难以推广使用

符号语言 为克服上述缺点而创造出来的，它是用一些英文字母和数字来表示一个指令。如：
ADD A,B（执行A+B=>A，将寄存器A中的数与寄存器B中的数相加，放到寄存器A中）

很明显，这并不能让计算机识别并执行，所以还需要一种汇编程序的软件将符号语言的指令转换为机器指令。这种转换的过程又叫做 “汇编” 或 “代真” ，故，符号语言又称符号汇编语言或汇编语言。

以上两种语言均为计算机低级语言。

高级语言 为克服低级语言的缺点而创造出来，更加利于人们理解。如要计算和输出3×6÷5，只需写：a=(3*6)/5;printf(“%d”,a);

计算机语言就简单介绍到这里，如需深度了解可上百度等各大浏览器查询。

C语言的特点

（1）语言简洁，使用方便。

（2）运算符丰富。

（3）数据类型丰富。

（4）具有结构化的控制语句（while语句，do…while语句，if…else语句，switch语句，for语句）。

（5）语法限制不太严格。

（6）C语言允许直接访问物理地址，能进行位（bit）操作，能实现汇编语言的大部分功能，可以直接对硬件进行操作。

（7）用C语言编写的程序可移植性好。

（8）生成目标代码质量高，程序执行效率高。

二、初识C语言程序

简单示例

【例1.1】输出下面一行代码。
Hello World！

#include<stdio.h>    
                     //这是编译预处理的一个指令
int main()           //定义一个主函数
{                    //函数开始的标志
    printf("Hello World!\n");  //printf是输出指令，即此时输出Hello World！
    return 0;        //函数结束时返回函数值0，写return 1;也行，只是返回值为1
}                    //函数结束的标志

1
2
3
4
5
6
7
8
9

运行结果：
Hello World!

在使用函数库中输入输出函数时，编译系统要求程序提供有关此函数的信息（例如对输入输出函数的声明和宏的定义，全局量的定义等），而我们的程序中的 “ #include<stdio.h> ” 的作用就是用来提供这些信息的。stdio.h 就是一个系统所提供的文件名

int表示该函数类型是一个整型的数据类型；

main是该函数的名字；

" return 0 ; "的作用是：当main函数执行结束前将整数0作为函数值，返回到调用函数处。

“ \n ” 是换行符。

注释

“ // ” 代表注释，在编译时注释的部分是不会产生目标代码，注释对运行不起作用，只是给人看的，而不是计算机执行的。

C语言允许注释的方法有两种：

① 以 // 开始的单行注释，以 // 开始，换行（Enter）时结束。只会注释掉 // 之后的所有的解释性语句（这里系统自动换行不算哦，因为你这段话在这一行放不下了），但是若为追求美观，可以换一行继续使用 // 进行注释

② / * （这里注释） * /，“ / * * / ”是多行注释，就是即使 使用了换行符（Enter）也会被注释掉，以 /* 开始，以 */ 结束。可单行使用，也可多行使用。
注释内又注释，这会导致注释可能会出错。

#include<stdio.h>    //这是编译预处理的一个指令 
/*
int main()          
{                    
    printf("Hello World!\n"); 
    return 0;        
}                   
*/

1
2
3
4
5
6
7
8
9
10
11

看看颜色是不是变了？这就说明这一段语句全部被注释掉了。

★特别注意 ! ! !

以上所有代码（包括英文、字符和标点符号）全部要用英文来写 ! ! !

好，如果你看懂了上面的代码，那我们继续下一道。

【例1. 2】求两个整数之和

解题思路：首先设置三个变量a, b, sum（变量可随便用任何字母或单词来表示），sum在这里我们代表两整数之和。用赋值运算符 “ = ” 将a，b相加后的和赋给sum。

#include<stdio.h>        //这是编译预处理的一个指令 
int main()               //定义一个主函数
{                        //函数开始的标志
    int a,b,sum;         //变量声明，定义 a,b,sum为整型变量
    a = 12;              //对变量a进行赋值
    b = 5;               //对变量b进行赋值
    sum = a + b;         //进行 a+b 运算，并把结果存放在sum中
    printf("%d",sum);    //printf是输出指令，sum的值输出
    return 0;            //函数结束时返回函数值0，写return 1; 也行，只是返回值为1
}                        //函数结束的标志

1
2
3
4
5
6
7
8
9
10
11
12

运行结果：
17

本人个人认为此处在注释中已经讲得很明白了，int这个整型的数据类型，在后面还会细讲。

【变式1】输入a, b两个整数，求两整数之和。

#include<stdio.h>
int main()
{
    int a,b,sum;
    scanf("%d %d",&a,&b);    //scanf是输入指令，输入 a 和 b 的值
    sum = a + b;
    printf("sum = %d",sum);//输出sum的值
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11

这个printf函数圆括号内有两个参数。

第一个参数是引号内的sum = %d\n，它是输出格式字符串，作用是输出用户希望输出的字符和输出的格式。其中sum = 是用户希望输出的字符，%d是指定的输出格式，d表示用 “ 十进制整数 ” 形式输出。

第二个参数sum表示要输出变量sum的值。

在执行printf函数时，将sum变量的值（以十进制整数表示）取代引号中的 %d 。如下图：

（图源《C程序设计（第五版）》谭浩强 著）

这里就仔细讲解一下printf函数和scanf函数。

printf()函数

printf()函数是式样化输出函数，一般用于向准则输出设备按规定式样输出消息。printf()函数的调用格式为：printf(“<式样化字符串>”,<参数表>);

注意，要用英文字符输入语句。

其中式样化字符串包括两部分内容：
一部分是正常字符，这些字符将按原样输出；另一部分是式样化规定字符，以 “ % ” 开端，后跟一个或几个规定字符，用来确定输出内容式样。参量表是需求输出的一系列参数，其个数务必于式样化字符串所阐明的输出参数个数一样多，各参数之间用英文逗号“ , ” 分开，且顺序逐一对应，不然会出现意想不到的错误。

函数原型：
int printf(const char * format, …);

函数值返回值为整型。若成功则返回输出的字符数，输出出错则返回负值。

scanf()函数

scanf() 是输入函数，就是我们从键盘中输入我们想要测试的数据。与 printf() 函数一样都被声明在头文件 stdio.h 里，因此在使用 scanf() 函数时要加上 #include <stdio.h> 。（在有一些实现中，printf() 和 scanf() 函数在使用时可以不使用预编译命令 #include 。）

函数原型：
int scanf (const char * restrict format , …);
（稍作了解即可）

返回值
scanf() 函数返回成功读入的数据项数，读入数据时遇到了 “ 文件结束 ” 则返回EOF。

如：
scanf (“%d %d”,&a,&b);

函数返回值为 int 型。如果 a 和 b 都被成功读入，那么 scanf 的返回值就是2；如果只有a 被读入，返回值为1（b 同样）；如果a 读取失败，返回值为0（b 同样）；如果遇到错误或遇到enf of file, 返回值为EOF。

&a,&b中的 & 是寻址操作符，&a表示对象a 在内存中的地址，是一个 右值。变量a , b的地址是在编译阶段分配的（存储顺序由编译器决定）。

注意！！！

如果 scanf 中 %d 是连着写的，如 “%d%d%d”，在输入数据时，数据之间不可以用逗号分隔，只能用空白字符（空格或Tab 键或者回车键）分隔——“2(空格)3(Tab)4”或“2(Tab)3(回车)4”等。若是“%d,%d,%d”，则在输入数据时必须加 “ , ” ，如：“2,3,4”。

【变式2】找两个整数中的较大者。

第一种方式：

#include<stdio.h>
int main()
{
    int a,b,max;
    scanf("%d,%d",&a,&b); //输入数据 a, b
    if(a >= b)            //如果 a >= b,则将 a赋值给 max
        max = a;
    else                  //否则，将 b赋值给 max
        max = b;
    printf("%d",max);     //输出 max
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

第二种方式：(使用函数)

#include<stdio.h>
int main()
{
    int max(int x,int y);    //定义函数
    int a,b,c;
    scanf("%d,%d",&a,&b);
    c=max(a,b);              //调用 max函数，将值赋给 c
    printf("max = %d\n",c);
    return 0;
}
//求两个整数中的较大者的 max函数
int max(int x,int y)//定义 max函数函数值为整型，x、y均为形式参数
{
    int z;
    if(x>y)
        z=x;
    else
        z=y;
    return z;    //将 z的值作为 max函数值，返回到调用函数的位置
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果：
8 ，5
max = 8

字符输入输出函数

除了使用 printf()、scanf()输出和输入字符外，C语言标准函数库还有一些专门用于字符输入输出的函数。

字符输出函数putchar()

putchar()函数的一般形式为：
putchar( c );
函数的功能是输出一个字符，并返回输出字符的ASCII码值。
“ putchar( c ); ”中c可以是字符常量、字符型变量或整型变量，即将一个整型数据作为ASCII码，输出相应的字符。

【例1. 2】putchar() 函数的使用

#include<stdio.h>
int main()
{
    int i = 97;
    char ch = 'a';    //声明并初始化
    putchar(i);       //输出字符 a
    putchar('\n');    //换行，可以输出控制字符，起控制作用
    putchar(ch);      //输出字符变量 ch的值 'a'
    return 0;
}
1
2
3
4
5
6
7
8
9
10

运行结果:
a
a

字符输入函数getchar()

getchar()函数的一般形式为：
getchar();
函数的功能是从键盘输入一个字符，返回值是该字符的ASCII码值。

【例1. 3】getchar()函数的使用

#include<stdio.h>
int main()
{
    int ch;
    ch = getchar();  //从键盘输入字符，该字符的ASCII码值赋给 ch
    putchar(ch);    //输出 ch对应的字符
    return 0;
}
1
2
3
4
5
6
7
8

运行结果：
a
a

注意：
执行getchar()函数输入字符时，输入字符后需要敲一个回车键（Enter），回车后才继续执行程序。getchar()函数也将空白符作为一个有效字符读入。因此，在getchar()函数连续输入多个字符时要连续输入，中间不要加空白符。

变量与常量

常量

在程序运行过程中，其值不能被改变的量称为常量。
常用的常量有以下几类：

1.整型常量

即没有小数部分的数。例如：2，-345，43
除了十进制，还可用八进制和 十六进制来表示整数。

2.浮点型常量

浮点型常量有两种表现形式：
（1）十进制小数形式，由数字和小数点组成。
注意：在一个值后面加上一个小数点，该值就是一个浮点数。例如：3是整数，3.00 、3. 都是浮点数。

（2）指数形式
例如：3.14e3（表示3.14×10³），–193e–3（表示–193×10﹣²³），0.123E2（表示0.123×10²）。
需要注意的是，e或E之前必须有数字，且e或E后面必须为整数，如不能够写 e4，12e0.2

3.字符常量

两种形式：
（1）普通字符，用单引号括起来的单个字符。
例：‘A’，‘b’，‘9’，‘?’
（2）转义字符
C语言还允许用一种特殊形式的字符常量，就是用单引号括起来，以字符 \ 开头的字符序列。

转义字符

科普三字母词：
??) ——> ]
??( ——> [

4.字符串常量

由一对双引号括起来的字符序列。如：“China”，“中国”，“a”
双引号不是字符串的一部分。
字符串的结束标志是 \0，不算做字符串内容。

存储：
例：char a[10]=“abcdef”;
char类型的数组a[10]，存放字符串abcdef。

#include<stdio.h>
int main()
{
    char s[] = "abdef";//字符串包含了\0，打印输出时遇到\0就结束程序
    char a[] = {'a','b','c','d','e','f','\0'};//这里一定要加\0，否则打印输出时会出错
    printf("%s\n",s);
    printf("%s\n",a);
    printf("abc\0def\n");
}
1
2
3
4
5
6
7
8
9

运行结果：
abcdef
abcdef
abc

5.define定义的标识符常量

可以用#define预处理指令来定义一个符号常量。例如：
#define PI 3.14
编译程序时，程序中所有的PI都会被替换成3.14。通常，这样定义的常量也称为符号常量。

格式：#define 符号常量名 符号常量的值
三者之间用空格隔开。为了和变量名区分开来，习惯上符号常量用大写字符表示。

#include<stdio.h>
#define MAX 100//定义MAX，其值是100
#define STR "abcdef"  //STR,abcdef是字符串
int main()
{
    printf("%d\n",MAX);
    int a=MAX;
    printf("%d\n",a);
    printf("%s\n",STR);//%s 是字符串输出符
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11

运行结果：
100
100
abcdef

6.枚举常量

一般形式：
enum 枚举类型名{ 常量1，常量2，常量3，…};

可以一 一列举出来的

#include<stdio.h>
enum Color//类型
{
//这三个是枚举常量，可能取值的
    RED,
    GREEN,
    BLUE
};
int main()
{
    int num = 10;
    enum Color a = RED;
    enum Color b = GREEN;
    enum Color c = BLUE;
    printf("%d\n",a);
    printf("%d\n",b);
    printf("%d\n",c); 
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

运行结果：
0
1
2

枚举类型在使用中有以下规定：¹

1、枚举值是常量，不是变量。不能在程序中用赋值语句再对它赋值。例如对枚举weekday的元素再作以下赋值： sun=5;mon=2;sun=mon; 都是错误的。

2、枚举元素本身由系统定义了一个表示序号的数值，从0 开始顺序定义为0，1，2，… 。如在weekday中，sun值为0，mon值为1， …,sat值为6。

变量

在程序运行过程中，其值能被改变的量称为变量。

const修饰的常变量

const修饰的变量，常属性不能被改变。使用const在一定程度上可以提高程序的安全性和可靠性。

const修饰的数据类型是指常类型，常类型的变量或对象的值是不能被改变的。

#include<stdio.h>
int main()
{
    const int a = 10;//在C语言中，const修饰的a，本质是变量，但是不能被修改，有着常量的属性
    printf("%d",a);
    return 0;
}
1
2
3
4
5
6
7

运行结果：
10

const int Max = 100；
Max++;  //程序错误
1
2

如果想修改Max的值，可定义一个指向Max的指针，通过指针来改变Max的值，注意GCC8.2和Clong8.0均会产生警告。

const int Max = 100;
int *p = &Max;
*p = 101;
//GCC8.2 会产生警告，并输出Max = 101
//Clong8.0 会产生警告，且Max值未改变
1
2
3
4
5

规定符

说明

(1) 可以在“%”和字母之间插进数字表示最大场宽。

例如：%3d 表示输出3位整型数，不够3位右对齐。
%9.2f 表示输出场宽为9的浮点数，其中小数位为2，整数位为6，小数点占一位，不够9位右对齐。
%8s 表示输出8个字符的字符串，不够8个字符右对齐。

如果字符串的长度、或整型数位数超过说明的场宽，将按其实际长度输出。但对浮点数，若整数部分位数超过了说明的整数位宽度，将按实际整数位输出；若小数部分位数超过了说明的小数位宽度，则按说明的宽度以四舍五入输出。

另外，若想在输出值前加一些0，就应在场宽项前加个0。

例如：%04d 表示在输出一个小于4位的数值时，将在前面补0使其总宽度为4位。

如果用非浮点数表示字符或整型量的输出格式，小数点后的数字代表最大宽度，小数点前的数字代表最小宽度。

例如：%6.9s 表示显示一个长度不小于6且不大于9的字符串。若大于9，则第9个字符以后的内容将被删除。

(2) 可以在“%”和字母之间加小写字母 l，表示输出的是长型数。

例如：%ld 表示输出 long 整数
%lf 表示输出 double 浮点数

(3) 可以控制输出左对齐或右对齐，即在"%" 和字母之间加入一个" - "号可说明输出为左对齐, 否则为右对齐。

例如：%-7d 表示输出7位整数左对齐
%10s 表示输出10个字符右对齐

运算符

1.算术运算符

注意：
（1）运算符%要求左右两个运算数据必须为整型数据，如5%2的值为3。
（2）相除时，结果为整数，小数部分舍去。但若除数或被除数中有一个为负值，则舍入的方向是不固定的。如5/3=1，但–5/3在有的计算机得到的结果是–1，而有的计算机上的结果是–2。C99规定采取 “向零取整” 的方法，即取整后向零取整。
（3）字符型数据可以和数值型数据进行运算，因为字符型数据在计算机中是用一个字节的整型数（ASCII码）表示的。如 ‘A’+1在进行运算时会把A的ASCII码65与1相加，最后得出结果就是66。

【例1. 4】算术运算符的使用

#include<stdio.h>
int main()
{
    printf("%d %% %d = %d\n",-7,4,-7%4);//求余
    return 0；
}
1
2
3
4
5
6

运行结果：
-7 % 4 = -3

这里有两个%，是为了在显示器上显示出来%。

2.赋值运算符

（1）简单赋值运算
“ = ”的作用是将赋值符号右边的对象的值赋值给左边的对象。例：x = 9;
把值9赋给x，实际意义是将10存储到x的存储单元中。
此处“ = ”是赋值符，而非等于号。等于号是“ == ”，例如：if(x==10)，意思是如果x等于10。

注：①10 = x是无效语句。赋值运算符的左侧必须是一个运算对象，此对象的值可以改变。10是整数常量，不能改变其值，不能给常量赋值。
②若参与赋值运算的运算对象的数据类型不同，则右边对象的数据类型会被转换成左侧对象的类型。

（2）复合赋值运算
在赋值运算符前加上其他运算符，例如在“ = ” 前加上“ + ”，运算符就变成了复合运算符“ += ”。
例：x += 10;
相当于 x = x+10;
其他算术运算符也可以与赋值运算符组合成复合赋值运算符。

【例1. 5】a = 5,求a += a – = a * a。

#include<stdio.h>
int main()
{
    int a = 5;
    a += a -=a * a;
    printf("a = %d\n",a);
    return 0;
}
1
2
3
4
5
6
7
8

运算结果：
a = – 40

3.关系运算符

关系运算符的结合性是“ 从左到右 ”。a < b > c <= d 与( (a < b) > c) <= d 相同。

注意：浮点数之间进行比较时，尽量只使用 “ < ” 和 “ > ”。因为浮点数使用近似值表示的，这会导致逻辑上相等的两数却不相等。

4.逻辑运算符

在逻辑运算中，如果运算对象的值为非0，则认为是逻辑真，否则认为是逻辑假。真用 1 表示，假用 0 表示。

逻辑非
例：int a=5;
!a的结果为0，因为a不等于0。

运算符 ! 的结合性是“ 从右到左 ”，而&&和 || 的结合性是“ 从左到右 ”。

在多个&&（或 ||）相连时，因结合性是从左到右，故当左边的运算对象为假（或真），停止运算。

5.其他运算符

自增、自减运算符

自增运算符++
当 i 变量每次都要加1时,可写为 i++,或++i
相当于 i = i +1;

自减运算符 – –
当 i 变量每次都要减1时,可写为 i – – 或 – – i
相当于 i = i – 1;

自增、自减运算符的结合性是“ 从右到左 ”。x * y++ 相当于x * (y++)，而并非是(x * y)++。

sizeof运算符

一般形式：sizeof(运算对象）
圆括号可有可无，但是当运算对象是数据类型是，必须加上圆括号。
例如：sizeof(int), sizeof x, sizeof(x), sizeof 34, sizeof(34)
sizeof的结合性是“ 从右到左 ”。

如果运算对象是表达式，那表达式将不会被执行，只会输出此表达式的数据类型所占的字节数。

#include<stdio.h>
int main()
{
    int a = 12,b = 1;
    printf("%zd\n",sizeof(a = a+b);
    printf("a = %d\n",a);
    return 0;
}
1
2
3
4
5
6
7
8

运算结果：
4
a = 12

sizeof运算的结果是一个无符号整数类型。C99新增了转换说明%zd用于输出 sizeof 运算结果的值。如果编译器不支持使用%zd，可以使用 %u 或 %lu 代替 %zd。

逗号运算符

逗号运算符（,）用于将两个表达式连接时。如：
a+b , a+c
一般形式：表达式1 , 表达式2
求解过程：先求表达式1，再求表达式2。整个逗号表达式的值是表达式2的值。

一个逗号表达式又可以与另一个表达式组成一个新的逗号表达式。所以逗号表达式的一般形式又可拓展为：
表达式1, 表达式2, 表达式3, … , 表达式 n

注意：逗号也用作分隔符。下面代码中的逗号都是分隔符，而非逗号运算符。

int a,b;
printf("%d %d",a,b);
1
2

ASCII码表

ASCII码表图源：http://t.csdn.cn/DrceW

运算符的优先级

运算符优先级图源：https://www.wendangwang.com/doc/75d2728bbb843fed98536860

★★数据类型

C语言的数据类型十分丰富，如下：（此处若概括不全，还望指出）

基本类型

整数类型

基本整型（int）

（1）声明 int 型变量
形式：int 变量名;
如：int num;
（2）初始化变量
初始化就是为变量赋值。可以在声明的同时赋值，如：int num = 4;

声明是给变量创建存储空间，初始化就是给变量定一个初始值。

其他整数类型

短整型(short int)
类型名为short int（或简写成 short）。short型是有符号类型，占用的存储单元可能比 int 小，常用于较小数值的场合以节省空间。

长整型(long int)
类型名为long int（或简写成 long）。long型是有符号类型，占用的存储单元可能比int 型大，常用于较大数值的场合。

双长整数(long long int)
类型名为long long int 或long long（C99标准加入）。long long 型占用的存储单元可能比 long型大，适用于更大数值的场合。该类型至少占64位，即8个字节，是有符号类型。

声明其他整数类型与 int型相同，如：
short s_count;
long int count;
long long ago;

（4）无符号的整数类型

所有有符号类型前加上关键字 unsigned，就变成无符号的整数类型。此类型只用于非负值得场合，取值范围也与有符号类型不同。

任何有符号类型前加上signed 并无实际意义，只起到强调作用。

整数溢出

在给某一类型变量赋值时，超过取值范围就会“溢出”，输出的结果就是错误的。

字符类型

char 型用来存储字符，但计算机使用数字编码来处理字符，即用特定的整数来表示特定的字符。目前最通用的编码是ASCII码。

标准ASCII码的编码范围是0~127，只需要7位二进制数表示即可。char 型通常被定义为8位的存储单元，因此足以满足存储ASCII表中的字符。

（1）声明char 型变量
char ch;
char color,choose;
以上声明创建了三个变量，并分别分配了一个字节的的存储单元。

（2）char 型变量初始化
若要字符变量初始化为字母A，如：
char grade = ‘A’;
字母A的ASCII码是65，系统把整数65赋值给grade。

对于特殊字符可以用转义字符的形式来给变量赋值。
char ch; //声明一个char 型的变量
ch = ‘\n’; //初始化为换行符，把ASCII码10赋给ch
ch = ‘\12’; //换行符的八进制表示
ch = ‘\xa’; //换行符的十六进制表示

存储字符实际上存储的是整数，故也可用整数来赋值。
char grade = 65; //65是A的ASCII码值
char ch = 10; //10是换行符的ASCII码值

注意数字不要超过127，否则会出错。

浮点型类型

C语言中的浮点数类型有 float型（单精度浮点型）、double型（双精度浮点型）和 long double型（长双精度浮点型）。

float型必须至少能表示6位有效数字，且取值范围至少是10^-37~10⁺³⁷。通常，系统存储一个 float型要占用32位，其中8位用来存储指数的值和符号，剩下的24位用于存储非指数部分及其符号。

double型和 float型的最小取值范围相同，但至少能表示10位有效数字。通常，double型占用64位，因此比 float型精度更高，取值范围更大。

如精度要求更高，可用 long double型。

初始化：
float pi;
pi=3.14
double area,quart;
float weight = 6.5e - 34;
long double g;

例： 计算数据类型的大小

#include<stdio.h>
int main()
{
    printf("int：%zd\n",sizeof(int));
    printf("short：%zd\n",sizeof(short));
    printf("long：%zd\n",sizeof(long));
    printf("long long：%zd\n",sizeof(long long));
    printf("char：%zd\n",sizeof(char));
    printf("float：%zd\n",sizeof(float));
    printf("double：%zd\n",sizeof(double));
    printf("long double：%zd\n",sizeof(long double));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

运行结果：
int：4
short：2
long：4
long long：8
char：1
float：4
double：8
long double：16

强制类型转换

一般形式：
（类型名）表达式
例：a=(int)1.4+(int)1.5;
注意：强制类型转换符右侧如果是变量，会把变量的值转换成圆括号中指定的数据类型，变量本身的类型不会改变。

int a = 10;
(float)a + 3.14;
1
2

变量a的值（10）被强制转换成float型，再和3.14相加。但a的类型还是int型，其值仍为10。

剩下的其他数据类型，我们将在其具体的知识点中讲到。

C语言程序的结构（简单了解即可）

（1）一个程序由一个或多个源程序文件组成。
一个源文件可以包括3个部分：
①预处理指令。如：#include，#define
②全局声明。放在函数外声明的是全局变量，函数内声明的是局部变量。
③函数定义。

（2）函数是 c程序中的主要组成部分。

（3）一个函数包括两部分。
①函数首部。即函数的第一行，包括函数名，函数类型，函数属性，函数参数（形式参数）名，参数类型。

一个函数名后面必须跟一对圆括号，括号内写函数的参数名及其类型。如果函数没有参数，可以在括号中写 void，也可以是空括号。
int main(void) 或 int main()

②函数体。

• 声明部分。变量，调用的函数进行声明。
• 执行部分。函数中的若干语句。

（4）程序总是从main函数开始执行的。

（5）程序中要求计算机的操作是由函数中的C语句完成的。

（6）在每个数据声明和语句的最后必须有一个分号。

（7）C语言本身不提供输入输出语句。

（8）程序应当包含注释。必要的注释，可以增加程序的可读性。

三、算法——程序的灵魂

程序=算法+数据结构

程序 =（对数据的描述）数据结构+（对操作的描述）算法

数据结构 =个体 + 个体的关系

算法 = 对存储数据的操作

算法的概念：算法是解决问题的方法和步骤。

算法的特征

（1）有穷性
一个算法必须总是在执行有穷步后结束，且每一步都必须在有穷时间内完成。

（2）确定性
每种情况所执行的操作，在算法中都有确切的规定，不会产生二义性。

（3）可行性
算法中的所有操作都可以通过已经实现的基本操作运算执行有限次来实现。

（4）零个或多个输入

（5）一个或多个输出

衡量算法的标准

1.时间复杂度
大概程序要执行的次数，而非执行的时间

2.空间复杂度
算法执行过程中大概所占用的最大内存

3.难易程度

4.健壮性

部分常用的算法

1.迭代法
2.枚举法
依据问题的部分条件，确定答案的大致范围，然后逐一验证所有可能的情况，这种算法也叫穷举法。
3.递归法
函数的自调用

n! 的递归调用算法描述

void fun(int n）
{
    int f;
    if(n==1) f=1;
    else f=f*fun(n-1);
}
1
2
3
4
5
6

4.递推法
由已知条件，得出中间推论，直至得到结果。

F(1)=1,F(2)=1;
F(n)=F(n-1)+F(n-2);
1
2

算法咱就不讲深了，算法课会学的。

总结

本篇适用于零基础或初学C语言的小伙伴们，本人也只是个小菜鸟，根据教材和教辅资料总结出来的C语言入门（一），如有错误的地方，或需要改进的，还望各位指点一二。
建议初学者，一定要边看边练，多多练习，才能更加深刻的理解代码的含义。

---

1. 此处资料来源于百度http://baike.baidu.com/l/R5Gwo7FM?bk_share=copy&fr=copy# ↩︎