1.c语言介绍 
		#include  /*头文件,预处理命令*/
		int main()      /*主函数名称.主函数类型是int.主函数是c语言中的唯一入口。*/
		{
			printf("Hello World!");    /*printf()格式输出函数*/
			return 0;    /*函数返回值*/
		}
2.书写规范
  1. 一个说明或一个语句占一行
  2. 函数体内的语句要有明显的缩进【通常以按下一个Tab为一个缩进】
  3. 括号要成对写
  4. 当一句可执行语句结束的时候末尾要有分号
  5. 代码中的所有符号均为英文半角符号
3.c语言注释
  1. 多行注释/*注释内容*/
  2. 单行注释//注释一行
4.标识符
标识符：编程时给变量或者函数起的名字就是标识符。
标识符可以是字母（A-Z,a-z）,数字（0-9），下划线（_）组成的字符串，并且第一个字符必须是字母和下划线。
  1. 标识符的长度最好不要超过8位
  2. 标识符是严格区分大小写的
  3. 标识符最好选择有意义的英文单词组成做到“见名知意”。不要使用中文符。
  4. 标识符不能是c语言的关键字。
5.变量及赋值
A.变量就是可以变化的量，每一个变量都有一个名字（标识符）。变量占据内存中的一定的存储单元。使用变量之前必须先定义变量，要区分变量名和变量值是两个不同的概念。
变量
变量定义的一般形式为：数据类型 变量名; 多个类型相同的变量：数据类型 变量名,变量名,变量名...; 
		int num; //定义了一个整形变量，变量名字叫num
		num = 100; //给num变量赋值为100
		int a,b,c; //同时声明多个变量，然后分别赋值
		a=1;
		b=2;
		c=3;
		printf("%d\n",num); //打印整形变量num
注意： B.变量赋值的两种方式：
  1. 1.先声明再赋值
  2. 2.声明的同时赋值
		//先声明再赋值
		int num;
		num = 100;
		//声明的同时赋值
		int x = 10;
5.基本数据类型

c语言中数据类型可分为：基本数据类型，构造数据类型，指针类型，空类型四大类。

数据类型
整型、实型与字符型
整型、实型与字符型

整型数据是指不带小数的数字。比如：年龄，班级人数，书的总页数。

整型

浮点数据是指带小数的数字。比如：体重，价格，圆周率等。

实型 注：c语言中不存在 字符串变量，字符串只能存在字符数组中！！！ 6.格式化输出语句

格式化输出语句，也可以说是占位输出，是将各种类型的数据按照格式化后的类型及指定的位置从计算机上显示。是有利于计算机能够准确的将我们所要类型的数据给我们。其格式为：printf("输出格式符"，输出项)

c语言中常用的格式化符：

格式化符
6.不可改变的常量

在程序执行过程中，值不发生改变的量称为常量。c语言中的常量可以分为直接常量和符号常量。

1.直接常量-也称字面量，是可以直接拿来使用，无需说明的量。

		printf("%d\n",100); //整型常量
		printf("%f\n",3.14);    //实型常量
		printf("%c\n",'A');    //字符常量
		printf("I love C");   //字符串常量

2.符号常量-用一个标识符来标识一个常量。形式为#define 标识符 常量值 【注意：符号常量的标识符一般使用大写字母，变量的标识符一般习惯使用小写字母。句尾没有分号！】

		#include 
		#define PI 3.14    //定义一个圆周率.注意没有;分号。
		int main()
		{
			printf("圆周率：%f\n",PI);
			return 0;
		}
7.自动类型转换 
		char c = 'a';
		int x;
		dobule d;
		float e;
		x = c; //字符类型可以自动转换为整型  97
		d = x;  //整型可以自动转换成浮点类型 97.000000
		e = x;  //整型可以自动转换成浮点类型 97.000000
类型转换
8.强制类型转换

强制类型转换是通过定义类型转换原酸来实现的。一般形式：(数据类型)(表达式)。其作用是把表达式的运算结果强制转换成类型说明符所表示的类型。

		double tempOne = 6.777;
		int tempTwo = (int)tempOne; //强制转换成int类型
		printf("%f\n",tempOne); //6.777000
		printf("%d\n",tempTwo);	//6
注意： 9.运算符号
算术运算符
基本算术运算符
自增自减运算
自增自减运算

注意：无论是a++还是++a都等同于a=a+1,在表达式执行完毕后a的值都自增了1,无论是a--还是--a都等同于a=a-1,在表达式执行完毕后a的值都自减少1。

赋值运算符

c语言分为简单赋值运算符【=】和复合赋值运算符【+=、*=、/=、%=】。

关系运算符

关系运算符 注意:关系表达式的值是真和假，在c程序用整数0 和1表示。
逻辑运算符
逻辑运算符
三目运算符

格式为：表达式1?表达式2:表达式3;

		#inclued 
		int main()
		{
			int money = 100;
			int price = 120;
			printf("我们买不买呢：");
			//输出y就买，输出n就不买。
			printf("%c\n",price<=money?'y':'n'); //\n
			return 0;
		}
优先级
优先级 优先级为1的优先级最高；优先级为10的优先级最低。
10、c程序结构语句
if语句
if语句
if-else语句
if-else语句 
		//判断是闰年还是平年
		#include 
		int main()
		{
			int year = 2014;
			if(year%4==0&&year%100!=0||year%400==0)
			{
				printf("%s\n","今年是闰年");
			}
			else
			{
				printf("$s\n","今年是平年");
			}
			return 0;
		}
多重if-else语句
多重if-else语句 
		#include 
		int main()
		{
			int score = 7200;
			if(score>=10000)
			{
				printf("钻石玩家");
			}
			else if(5000<=score<10000)
			{
				printf("白金玩家");
			}
			else if(1000<=score<5000)
			{
				printf("青铜玩家");
			}
			else
			{
				printf("普通玩家");
			}
			return 0;
		}
分支结构之嵌套if-else语句
分支结构之嵌套if-else语句 
		#include 
		int main()
		{
			int sale = 120;
			int year = 1;
			if(sale>100)
			{
				if(year>2)
				{
					printf("获奖");
				}
				else
				{
				printf("很遗憾，期望你再接再厉")
				}
			}
			else
			{
				printf("很遗憾，期望你再接再厉")
			}
			return 0;
		}
循环结构之while循环
循环结构之while循环 
		#include 
		int main()
		{
			int sum = 0;
			int i = 0;
			while(i<=100)
			{
				sum+=i;
				i++;
			}
			printf("100以内所有整数之和为：%d\n",sum);
			return 0;
		}
循环结构之do-while循环
循环结构之do-while循环 注意：do-while循环至少要执行一次循环语句 
		/*任务
某公司2014年在职人数为200人，以每年20%增长速度不断扩大招工规模，请使用do-while循环计算从2014开始至哪一年招工规模能够突破1000人。*/
		#include 
		int main()
		{
			int number = 200;
			int year = 2014;
			do
			{
				number = number*1.2; //number+number*20%
				year++;
			}while(number<1000);
			printf("到%d年招工规模突破1000人",year);
			return 0;
		}
循环结构之for循环
循环结构之for循环 
		/*任务1.
体验一下for循环，实现一个10以内的数之和的小程序。*/
		#include 
		int main()
		{
			int sum,num;
			for(num=0;num<=10;num++)
			{
				sum+=num;
			}
			printf("10以内数的和为：%d\n",sum);
			return 0;
		}
		/*任务2
输出所有水仙花数字。所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数*/
		#include 
		int main()
		{
			//定义三位数num,个位数sd,十位数td,百位数hd
			int num,sd,td,hd;
			for(num=100;num<1000;num++)
			{
				sd = num%10;  //个位
				td = (num%100)/10; //十位
				hd = num/100; //百位
				if(num==sd*sd*sd+td*td*td+hd*hd*hd)
				{
					printf("水仙花数字：%d\n",num);
				}
			}
			return 0;
		}
循环结构之三种循环比较
		/*使用循环计算1-2+3-4+5-6+…-100的值？ */
		#include 
		int main()
		{
		    /* 小伙伴们：
		           选择你们认为最合理的循环结构完成功能吧 */
		    int sum = 0;  //定义计算结果变量sum
		    int i = 1;    //定义循环数字变量i
		    int flag = 1; //定义符号状态变量flag
		    
		    //使用while循环
		    while(i<=100)
		    {
		        i++;
		        flag = i%2==0?1:-1;
		        sum = sum+flag*i;		        
		    }
		    printf("sum=%d\n",sum); 
		    return 0;    
		}
循环结构之多重循环
		/*任务1.
使用双重循环实现输出正三角形，效果如下*/
	#include 
	int main()
	{
		int i,j,k;
		for(i=0;i<5;i++)
		{
			for(j=i;j<5;j++)//输出空格
			{
				printf(" ");
			}
			for(k=0;k<2*i-1;k++)
			{
				printf("*");
			}
			printf("\n");
		}
		return 0;
	}
	
		/*任务2.使用for循环打印9×9乘法表*/
		#include 
		int main()
		{
			int i,j;
			for(i=9;i>0;i--)
			{
				for(j=1;j
	
结束语句之break语句

	
		/*任务
找出0-50之间的所有素数，所谓素数就是只能被1和它本身整除的数字，比如：7，13，23等。*/
		#include 
		int main()
		{
		    int m, n;
		    for(m=2;m<=50;m++)
		    {
		    	for(n=2;n < m;n++)
		    	{
		    		if(m%n==0)
		    		{
		    			break;
		    		}
		    	}
		    	if(m==n) printf("%d\n",m);
		    }
			return 0;    
		}
	

	
结束语句之continue语句

	
		/*任务
计算1到20之间不能被3整除的数字之和。*/
		#include 
		int main()
		{
		    int i, sum;
		   for(i=1;i<=20;i++)
		   {
		       if(i%3==0)
		       {
		         continue;  
		       }
		        sum+=i;
		  }
		   printf("sum=%d",sum);
		    return 0;    
		}
	

	
分支结构之switch语句

	
		#include 
		int main() 
		{
		    int score = 87; //考试分数为87分 
		    score=score/10;
		    switch(score)
		    {
		        case 10:
		        case 9:
		            printf("等级A");
		            break;
		        case 8:
		            printf("等级B");
		            break; 
		        case 7:
		        case 6: 
		            printf("等级C");
		            break;   
		        default:
		            printf("等级D");
		            break;    
		    }
		    return 0;
		}
	

	
switch与if语句的应用

	
		/*任务：请使用switch语句和if...else语句，计算2008年8月8日这一天，是该年中的第几天。*/
		#include 
		int main() 
		{ 
		    /* 定义需要计算的日期 */
		    int year = 2008;
		    int month = 8;
		    int day = 8;
		    int sum,flag;
		    
		    switch(month)
		    {
		        case 1:sum = 0;break;
		        case 2:sum = 31;break;
		        case 3:sum = 59;break;
		        case 4:sum = 90;break;
		        case 5:sum = 120;break;
		        case 6:sum = 151;break;
		        case 7:sum = 181;break;
		        case 8:sum = 212;break;
		        case 9:sum = 243;break;
		        case 10:sum = 273;break;
		        case 11:sum = 304;break;
		        case 12:sum = 334;break;
		        default:printf("一年只有12个月");break;
		                
		    }
		    sum = sum+day;
		    if(year%4==0&&year%100!=0||year%400==0)
		    {
		        flag = 1;
		    }
		    else
		    {
		        flag = 0;
		    }
		    if(flag==1&&month>2)
		    {
		        sum++;
		    }
		    printf("2008年%d月%d日是该年的第%d天",month,day,sum);
			return 0;
		}
	

	
臭名远扬之goto语句

	
		/*求10以内的数之和*/
		#include 
		int main()
		{
			int sum = 0;
			int i = 1;
			LOOP:if(i<=10)
			{
				sum+=i;
				i++;
				//转义到LOOP所在位置继续执行
				goto LOOP;
			}
			printf("sum=%d\n",sum);
			return 0;
		}
		/*实现从控制台输出1-10，使用goto语句，实现当输出完3之后跳出循环体。*/
	

	11.函数
	
自定义函数的一般形式：

	自定义函数的一般形式
	
    
		
  • 注意：1、[]包含的内容可以省略，数据类型说明省略，默认是int类型函数；参数省略表示该函数是无参函数，参数不省略表示该函数是有参函数；
    • 
		
  • 2、函数名称遵循标识符命名规范；
    • 
		
  • 3、自定义函数尽量放在main函数之前，如果要放在main函数后面的话，需要在main函数之前先声明自定义函数，声明格式为：[数据类型说明] 函数名称（[参数]）;
    • 
	

	c语言中，函数调用的一般形式为：函数名（[参数]）; 
 
    
 	
  • 注意：1.对无参函数调用的时候可以将【】包含的省略；
    • 
 	
  • 2.【】中可以是常熟，变量或其它构造类型数据及表达式，个参数之间用逗号分隔。
    • 
 

 	
 		#include 

 		/* 自定义整型函数 sayLove() */
 		int sayLove()
 		{
 		    //在这里输入输出语句printf，输出内容为I Love imooc 
 		    printf("%s\n", "I Love imooc");
 		    return 0;
 		}

 		/* 自定义整型函数 dividLine() */
 		int dividLine()
 		{
 		    printf("%s\n", "*************");
 		    return 0;
 		}

 		/* 主函数 */
 		int main()
 		{
 		    /* 调用所写函数 */
 		    dividLine();
 		    sayLove();
 		    dividLine();
 		    return 0;
 		}
 	

 	
有参与无参

 	有参与无参
 	
#include 
/* 考虑一下哪个输出该用无参函数哪个输出该用有参函数呢？ */

int study()
{
    printf("小明在慕课网上学习");
    return 0;
}

int studyNum(int num)
{
    printf("小明在慕课网上已经参与学习了%d门课程",num);
    return 0;
}

int main()
{
    study();
    studyNum(5);
    return 0;
}

	
形参与实参

	
函数的参数分为形参和实参两种。形参是在定义函数名和函数体的时候使用的参数，目的是用来接收调用该函数时传入的参数。实参是调用时传递该函数的参数。形参只有在函数内部有效。

	
		#include 
		int getGirth(int a,int b,int c)
		{
		    if( (a+b)<=c || (a+c)<=b || (b+c)<=a )   //判断是否为三角形
		    {
		        printf("不构成三角形\n");
		        return 0;                                
		    }
		    else
		    {
		      int cirf = a+b+c ;     //计算三角形周长
		      return cirf;
		    }
		       
		}

		int main()
		{
		    /* 定义三角形三边长 */
		    int a, b, c;
		    a = 3;
		    b = 4;
		    c = 5;
		    printf("三角形的周长是：%d\n", getGirth(a,b,c));  //调用周长函数
		    return 0;
		}
	

	
函数的返回值

	没有返回值的函数，返回类型是void.注意：void函数中可以有执行代码块，但是不能有返回值，另void函数中如果有return语句，该语句只能起到结束函数运行的功能。其格式为：return;
	
		#include 
		/* Jone算出结果应该怎么写函数？ */
		 int  joneResult(int x, int y, int z)
		{
		   int sum = x+y+z;
		   return sum/3;          //这里是不是应该将sum返回呢？
		}
		/* Jack没有算出结果只说了一句话是不是应该用无返回值函数？ */
		void jackResult(int x, int y, int z)
		{
		    printf("我算不出来\n");
		}
		int main()
		{
		    int a, b, c;
		    a = 10;
		    b = 20;
		    c = 30;
		    //Jone的返回值类型是什么？
		    int  jR = joneResult(a, b, c); 
		    printf("Jone运算结果是：%d\n", jR);
		    printf("Jack运算结果是：");
		    //Jack没有算出结果只说了句话，是不是直接调用函数就可以了？
		    jackResult(a,b,c);
		    return 0;
		}
	

	
递归函数（一）

	
递归就是一个函数在它的函数体内调用它自身。

	
		#include 
		int factorial(int n)
		{
			int result;
			if(n<0)
			{
				printf("输入错误！\n");
				return 0;
			}
			else if(n==0||n==1)
			{
				result = 1;
			}
			else
			{
				result = factorial(n-1)*n;//调用自身
			}
			return result;
		}

		int main()
		{
			int n = 5;
			printf("%d的阶乘=%d",n,factorial(5));
			return 0;
		}
	

	
		#include 
		/* 定义获取单词数量的函数 */
		int getWordNumber(int n)
		{   
		    if(n == 1)
		    {
		        return 1;    //第一天只会1个单词
		    }
		    else{
		        return getWordNumber(n-1)+n;       //到第天会的单词数量
		        //第n天我们学会了n个单词加上之前我们学会的getWordNumber（n-1）个单词，正好学会了n+getWordNumber（n-1）个单词
		    }
		}
		int main()
		{
		    int num = getWordNumber(10);     //获取会了的单词数量
		    printf("小明第10天记了:%d个单词。\n", num);
		    return 0;
		}
	

	
递归函数（二）

	递归函数
	
    
		
  • 递归函数特点：1.每一级函数调用都有自己的变量，但是函数代码并不会得到复制，如计算5的阶乘时每递推一次变量都不同。
    • 
		
  • 2.每次调用都会有一次返回，如计算5的阶乘时每递归一次都返回进行下一次。
    • 
		
  • 3.递归函数中，位于递归调用前的语句和各级被调用函数具有相同的执行顺序。
    • 
		
  • 4.递归函数中，位于递归调用后的语句的执行顺序是和各个被调用函数的顺序相反；
    • 
		
  • 5.递归函数中必须有终止语句。
    • 
	

	
递归：自我调用且有完成状态。

	任务：猴子第一天摘下N个桃子，当时就吃了一半，还不过瘾，就又多吃了一个。第二天又将剩下的桃子吃掉一半，又多吃了一个。
以后每天都吃前一天剩下的一半零一个。到第10天在想吃的时候就剩一个桃子了,问第一天共摘下来多少个桃子？并反向打印每天所剩桃子数。
	
		#include 
		int getPeachNumber(int n)
		{
		    int num;    //定义所剩桃子数
		    if(n==10)
		    {
		       return 1;     //递归结束条件
		    } 
		    else
		    {
		        num = (getPeachNumber(n+1)+1)*2;   //这里是不应该用递归呢？
		/*getPeachNumber(2)=getPeachNumber(1)/2 - 1
		推出
		getPeachNumber(1)=（getPeachNumber(2)+1）*2
		所以
		num = (getPeachNumber(n+1)+1)*2*/
		        printf("第%d天所剩桃子%d个\n", n, num); //天数，所剩桃子个数
		    }
		    return num;
		}
		int main()
		{
		    int num = getPeachNumber(1);
		    printf("猴子第一天摘了:%d个桃子。\n", num);
		    return 0;
		}
	

	递归函数练习：有5个人坐在一起，问第5个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。
问第3个人，又说比第2人大两岁。问第2个人，说比第1个人大两岁。最后 问第1个人，他说是10岁。请问第5个人多大？
	
		#include  
		/* 
		 * 请使用递归函数完成本题
		 * 小编已将正确代码放在左侧任务的“不知道怎么办”里
		 * 小编希望各位童鞋独立完成哦~
		 */
		int ageNum(int num)
		{
		    int age;
		    if(num==1)
		    {
		        age = 10;
		    }
		    else
		    {
		        age = ageNum(num-1)+2;
		    }
		    return age;
		}

		int main() 
		{
			printf("第5个人的年龄是%d岁", ageNum(5)); 
			return 0;
		}
	

	
局部与全局

	
局部变量也称为内部变量，作用域是复合语句范围内。全局变量也称为外部变量，作用域是整个源程序。

	
变量存储类别

	
c语言根据变量的生存周期来划分，可以分为静态存储方式和动态存储方式。C语言中存储类别又分为四类：自动（auto）、静态（static）、寄存器的（register）和外部的（extern）。

	
内部函数与外部函数

	
C语言中不能被其他源文件调用的函数称谓内部函数 ，内部函数由static关键字来定义，因此又被称谓静态函数，形式为：static [数据类型] 函数名（[参数]） 。在C语言中能被其他源文件调用的函数称谓外部函数 ，外部函数由extern关键字来定义，形式为：extern [数据类型] 函数名([参数]) 

	
		/*北京市出租车打车计费规则如下：

1. 每公里单价计费2.3元

2. 起步价13元(包含3公里)

3. 晚上23点(含)至次日凌晨5点(不含)打车，每公里单价计费加收20%。

4. 每次乘车加收1元钱的燃油附加税。

小明每天上下班都要打车，公司和家的距离为12公里，上午上班时间为9点，下午下班时间为6点。

请编写一个小程序计算小明每天打车的总费用。*/
		#include 
		float fees(float distance,int time)
		{
		    float fee;
		    if(time<5||time>=23) 
		    {
		        fee = 13+(distance-3)*2.3*1.2;
		    }
		    else
		    {
		        fee = 13+(distance-3)*2.3;
		    }
		    return fee+1;
		}
		int main()
		{
		    printf("小明打车的总费用%f\n",fees(12,9)+fees(12,18));
		    return 0;
		}
	

	12.数组
	
数组：在程序中是一块连续的，大小固定并且里面的数据类型一致的内存空间。声明数组：数据类型 数组名称【长度】。

	
    
		
  • 数组初始化：1.数据类型 数组名称[长度n] = {元素1,元素2…元素n};
    • 
		
  • 2. 数据类型 数组名称[] = {元素1,元素2…元素n};
    • 
		
  • 3. 数据类型 数组名称[长度n]; 数组名称[0] = 元素1; 数组名称[1] = 元素2; 数组名称[n-1] = 元素n;
    • 
	

	
		/*任务
		替换指定数组中的最大元素。要求指定整数为数组arr2中的第一个元素arr2[0]。*/
		#include 
		void replaceMax(int arr[],int value)
		{
		    int max = arr[0];
		    int index = 0;
		    int i;
		    for(i=1;i<5;i++)
		    {
		        if(arr[i]>max)
		        {
		            max=arr[i]; //将数组中较大的数赋值给max
		            index = i;  //记录当前索引
		        }                
		    }  
		    arr[index] = value;
		}

		int main()
		{
		    int arr1[] = {10,41,3,12,22};
		    int arr2[] = {1,2,3,4,5};
		    int i;
		    replaceMax(arr1,arr2[0]); //将数组arr1和数组arr2的第一个元素传入函数中
		    for(i=0;i<5;i++)
		    {
		        printf("%d ",arr1[i]);                
		    }
		    return 0;    
		}
	

	
冒泡排序:相邻元素两两比较，将较大的数字放在后面，直到将所有数字全部排序。

	
		/*小明班级有10人要参加比赛，进场时要按大小个升序排队，老师要用冒泡排序写一个小程序进行排序*/
		#include 
		int main()
		{
		    double arr[]={1.78, 1.77, 1.82, 1.79, 1.85, 1.75, 1.86, 1.77, 1.81, 1.80};
		    int i,j;
		    printf("\n************排队前*************\n");
		    for(i=0;i<10;i++)
		    {
		        if(i != 9)   
		            printf("%.2f, ", arr[i]);  //%.2f表示小数点后精确到两位
		        else
		            printf("%.2f", arr[i]);    //%.2f表示小数点后精确到两位
		    }
		    for(i=8; i>=0; i--)
		    {
		        for(j=0;j<=i;j++)
		        {
		            if(arr[j]>arr[j+1])      //当前面的数比后面的数大时
		            {
		                double temp;    //定义临时变量temp
		                temp=arr[j];     //将前面的数赋值给temp
		                arr[j]=arr[j+1]; //前后之数颠倒位置
		                arr[j+1]=temp;  //将较大的数放在后面    
		            }                 
		        }                
		    }
		    printf("\n************排队后*************\n");
		    for(i=0;i<10;i++)
		    {
		        if(i != 9)   
		            printf("%.2f, ", arr[i]);  //%.2f表示小数点后精确到两位     
		        else
		            printf("%.2f", arr[i]);    //%.2f表示小数点后精确到两位
		    }
		    return 0;    
		}
	

	
		/*数组元素的查找功能*/
		#include 
		int getIndex(int arr[5],int value)
		{
		    int i;
		    int index;
		    for(i=0;i<5;i++)
		    {
		       /* 请完善数组查询功能 */
		       if(arr[i]==value)
		       {
		        index = i;  
		        break;
		       }
		       
		    }
		    return index;
		}

		int main()
		{
		    int arr[5]={3,12,9,8,6};
		    int value = 8;
		    int index = getIndex(arr, value);      //这里应该传什么参数呢？
		    if(index!=-1)
		    {
		        printf("%d在数组中存在，下标为：%d\n",value,index);             
		    }
		    else
		    {
		        printf("%d在数组中不存在。\n",value);    
		    }
		    return 0;    
		}
	

	
字符串与数组

	
数组定义字符串。1.char 字符串名称[长度] = "字符串值";2.char 字符串名称[长度] = {'字符1','字符2',...,'字符n','\0'};在输出字符串的时候要使用：printf(“%s”,字符数组名字);或者puts(字符数组名字);

	
		#include 
		/* 定义say函数 */
		void say(char string[])       //数组参数应该怎么写呢？
		{
		    printf("%s\n",string);     //打印字符串
		}

		int main()
		{
		    //定义字符串数组
		    char string[] = "我在慕课网上学习IT技能！";
		    say(string);                 //调用say函数输出字符串
		    return 0;
		}
	

	
字符串函数

	字符串函数
	
注意：1.strlen()获取字符串的长度，在字符串长度中是不包括‘\0’而且汉字和字母的长度是不一样的。
2.strcmp()在比较的时候会把字符串先转换成ASCII码再进行比较,返回的结果为0表示s1和s2的ASCII码相等,返回结果为1表示s1比s2的ASCII码大,返回结果为-1表示s1比s2的ASCII码小。
3.strcpy()拷贝之后会覆盖原来字符串且不能对字符串常量进行拷贝
4、strcat在使用时s1与s2指的内存空间不能重叠，且s1要有足够的空间来容纳要复制的字符串

	
		/*输出我爱，慕课网*/
		#include 
		#include 
		int main()
		{
		    char s1[100]="";
		    char s2[]="我爱,";
		    char s3[]="慕课网";
		    /*在以下补全代码*/
		    strcpy(s1,s2);
		    strcat(s1,s3);
		    printf("%s\n",s1);
		    return 0;    
		}
	

	
多维数组

	
多维数组的初始化与一维数组的初始化类似也是分两种：

	

		1、数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n] = {{值1,..,值n},{值1,..,值n},...,{值1,..,值n}};
		2、数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n]; 数组名称[下标1][下标2]...[下标n] = 值;
	

	二维数组定义的时候，可以不指定行的数量，但是必须指定列的数量。
	
		#include 
		int main()
		{
		    //使用第一种方式初始化方式声明并初始化二维数组arr1
		    int arr1[2][2]={{10,20},{30,40}};
		    //使用第二种方式初始化方式声明并初始化二维数组arr2
		    int arr2[2][2];
		    arr2[0][0]=10;    
		    arr2[0][1]=20;    
		    arr2[1][0]=30;    
		    arr2[1][1]=40;
		    return 0;    
		}
	

	
多维数组的遍历

	
/*现有三行三列的二维数组int arr[3][3] = {{1,2,3},{4,5,6},{7,8,9}};，编写程序实现计算对角线元素之和。*/
		#include 
		int main()
		{
		    int arr[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
		    int i,j;
		    int sum=0;
		    int sum1=0;
		    int sum2=0;
		    for(i=0;i<3;i++)
		    {
		        for(j=0;j<3;j++)
		        {
		            if((i+j)%2==0)
		            {
		                sum+=arr[i][j];
		            }
		        }
		    }
		    printf("对角线元素之和是：%d\n",sum);
		    return 0;    
		}
	

	
		/*在一个长度为10的整型数组里面，保存了班级10个学生的考试成绩。要求编写5个函数，分别实现计算考试的总分，最高分，最低分，平均分和考试成绩降序排序。*/
		#include 
int total(int arr[])
{
    int sum = 0;
    int i;
    for(i=0;i<10;i++)
    {
        sum+=arr[i];
    }
    return sum;
}
int average(int arr[])
{
    int all = total(arr);
    int ave = all/10;
    return ave;
}
int max(int arr[])
{
    int maxValue = arr[0];
    int i = 0;
    for(i=0;i<10;i++)
    {
        if(maxValue