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

目录

• 一、简单了解C语言和程序设计
• • 了解什么是计算机程序和计算机语言
  • C语言的特点
• 二、初识C语言程序
• • 简单示例
  • • 注释
    • printf()函数
    • scanf()函数
    • 字符输入输出函数
    • • • 字符输出函数putchar()
        • 字符输入函数getchar()
  • 变量与常量
  • • 常量
    • • 1.整型常量
      • 2.浮点型常量
      • 3.字符常量
      • • • 转义字符
      • 4.字符串常量
      • 5.define定义的标识符常量
      • 6.枚举常量
    • 变量
    • • const修饰的常变量
  • 规定符
  • 运算符
  • • • • 1.算术运算符
        • 2.赋值运算符
        • 3.关系运算符
        • 4.逻辑运算符
        • 5.其他运算符
        • • 自增、自减运算符
          • sizeof运算符
          • 逗号运算符
  • ASCII码表
  • 运算符的优先级
  • ★★数据类型
  • • • 基本类型
      • • 整数类型
        • • 基本整型（int）
          • 其他整数类型
          • 整数溢出
          • 字符类型
        • 浮点型类型
      • 强制类型转换
  • 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    
                     //这是编译与处理的一个指令
int main()           //定义一个主函数
{                    //函数开始的标志
    printf("Hello World!\n");  //printf是输出指令，即此时输出Hello World！
    return 0;        //函数结束时返回函数值0，写return 1;也行，只是返回值为1
}                    //函数结束的标志

运行结果：
Hello World!

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

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

main是该函数的名字；

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

“ \n ” 是换行符。

注释

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

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

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

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

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

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

★特别注意 ! ! !

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

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

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

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

#include        //这是编译与处理的一个指令 
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
}                        //函数结束的标志

运行结果：
17

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

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

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

这个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 。（在有一些实现中，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
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;
}

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

#include
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函数值，返回到调用函数的位置
}

运行结果：
8 ，5
max = 8

字符输入输出函数

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

字符输出函数putchar()

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

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

#include
int main()
{
    int i = 97;
    char ch = 'a';    //声明并初始化
    putchar(i);       //输出字符 a
    putchar('\n');    //换行，可以输出控制字符，起控制作用
    putchar(ch);      //输出字符变量 ch的值 'a'
    return 0;
}

运行结果:
a
a

字符输入函数getchar()

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

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

#include
int main()
{
    int ch;
    ch = getchar();  //从键盘输入字符，该字符的ASCII码值赋给 ch
    putchar(ch);    //输出 ch对应的字符
    return 0;
}

运行结果：
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语言还允许用一种特殊形式的字符常量，就是用单引号括起来，以字符 \ 开头的字符序列。

转义字符 ooo#include

转义字符	含义
\n	换行
\f	清屏并换页
\r	回车
\t	Tab符,水平制表符
\v	垂直制表符
\b	退格
\	反斜杠（\）
\’	单引号
\"	双引号
\a	报警
	空值	\?
在书写连续多个问号时使用，防止他们被解析成三字母词		八进制值（ooo必须是有效地八进制数，即每个o表示0~7中的一个数）
\xhh	十六进制值（hh必须是有效的十六进制数，即每个h表示0~f 中的一个数）

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

4.字符串常量

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

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

intmain
( )char[
{
    ] s="abdef" ; //字符串包含了char，打印输出时遇到[就结束程序]=
    'a' a,'b' , {'c','d','e','f','}';//这里一定要加printf，否则打印输出时会出错("%s\n",);
    printf("%s\n",s);
    printf("abc)def\n";a}#
    include#defineMAX100
//定义MAX，其值是100

运行结果：
abcdef
abcdef
abc

5.define定义的标识符常量

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

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

#define
STR"abcdef" //STR,abcdef是字符串 intmain
() printf (  "%d\n"
, );int
{
    =;printf(MAX"%d\n",
    ) a;MAXprintf
    ("%s\n",)a;//%s 是字符串输出符
    return0;}STR#includeenum
    Color //类型//这三个是枚举常量，可能取值的
,

运行结果：
100
100
abcdef

6.枚举常量

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

可以一 一列举出来的

,}
; intmain
{
(
    RED)
    GREENint
    BLUE
=10
; enumColor=
{
    ; num enum Color=
    ; enum a Color RED=
    ; printf b ( GREEN"%d\n"
    , ) c ; BLUEprintf
    ("%d\n",)a;printf
    ("%d\n",)b;return
    0;}1c#include 
    int main(
)

运行结果：
0
1
2

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

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

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

变量

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

const修饰的常变量

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

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

int=
10 ;//在C语言中，const修饰的a，本质是变量，但是不能被修改，有着常量的属性printf
{
    ( "%d" a , );return
    0;}constaint=
    100 ++;
//程序错误

运行结果：
10

const int Max = 100；
Max;int  *

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

= & Max ; *=
101 ;p //GCC8.2 会产生警告，并输出Max = 101 //Clong8.0 会产生警告，且Max值未改变Max转换说明
输出结果p %d、%i 十进制有符号整数%u
十进制无符号整数
%f

规定符

浮点数	%lf
double浮点数	%s
字符串	%c
单个字符	%p
指针的值(输出地址符）	%e、%E
指数形式的浮点数	%x,%X
无符号以十六进制表示的整数	%o
无符号以八进制表示的整数	%g、%G
把输出的值按照%e或者%f类型中输出长度较小的方式输出	%lu
32位无符号整数	%llu
64位无符号整数	%zu
打印sizeof 的返回值	%%
输出一个百分号	运算符
含义	范例
结果	+
加法	x+y

说明

(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.算术运算符 #includeintmain()printf

x和y的和	–	减法	x–y
x和y的差	*	乘法	x * y
x和y的积	/	除法	x / y
x和y的商	%	求余	x%y
x除以y的余数	+	正号	+x
x的值	–	负号	–x
x的相反数

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

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

("%d %% %d = %d\n"
, -7,
{
    4,-7%4);//求余return0}此处“ = ”是赋值符，而非等于号。等于号是“ == ”#includeint
    main (；
)

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

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

2.赋值运算符

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

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

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

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

=5
; +=-=*
{
    ; a printf ("a = %d\n"
    a , a )a ; areturn
    0;}关系运算符a含义范例
    < 小于x
大于

运算结果：
a = – 40

3.关系运算符 或或等于等于

<=	x<=y
==	等于
>	x==y	x>y
!=	小于	不等于	x!=y
>=	大于		x>=y
	逻辑运算符	含义
范例	&&	逻辑与
关系运算符的结合性是“ 从左到右 ”。a < b > c <= d 与( (a < b) > c) <= d 相同。	x && y	∣∣

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

4.逻辑运算符

逻辑或	x ∣∣ y	!
逻辑非	!x	在逻辑运算中，如果运算对象的值为非0，则认为是逻辑真，否则认为是逻辑假。真用 1 表示，假用 0 表示。
		a
b	!a	!b
a&&b	a∣∣b	真

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

圆括号可有可无，但是当运算对象是数据类型是，必须加上圆括号。#includeintmain()

真	假	假	真	真	真
假	假	真	假	真	假
真	真	假	假	真	假
假	真	真	假	假

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

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

5.其他运算符 自增、自减运算符

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

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

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

sizeof运算符

一般形式：sizeof(运算对象）
int
例如：sizeof(int), sizeof x, sizeof(x), sizeof 34, sizeof(34)
sizeof的结合性是“ 从右到左 ”。

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

=12
, =1;
{
    printf a ( "%zd\n",b sizeof (=
    +);printf("a = %d\n"a , a)b;return
    0;}inta,;
    printf ("%d %d"
,

运算结果：
4
a = 12

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

逗号运算符

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

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

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

, a)b;
-37+37#includeaintbmain(

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)~10printf。通常，系统存储一个 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;

例： 计算数据类型的大小

("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));return0; }int=10
    ; (float
)

运行结果：
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;
注意：强制类型转换符右侧如果是变量，会把变量的值转换成圆括号中指定的数据类型，变量本身的类型不会改变。

+ a 3.14 ;剩下的其他数据类型，我们将在其具体的知识点中讲到。
声明部分。变量，调用的函数进行声明。
执行部分。函数中的若干语句。
voida fun (int

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

int

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

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

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

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

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

②函数体。

;if

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

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

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

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

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

三、算法——程序的灵魂 程序=算法+数据结构

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

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

算法 = 对存储数据的 *** 作

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

算法的特征

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

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

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

（4）零个或多个输入

（5）一个或多个输出

衡量算法的标准

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

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

3.难易程度

4.健壮性

部分常用的算法

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

n! 的递归调用算法描述

( ==1) n）
{
    = f1
    ;elsen=*fun f(-1
    ) f;f}F(n1)=1
,

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

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

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

总结

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

---

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