------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
**************************基础语法*********************
===========================一、关键字===================
1>关键字：C语言提供的有特殊含义的符号，也叫做“保留字”
2> C语言一共提供了32个关键字,常用关键字
return / void/ int/ float/ double/ char/ for/ while/ if/ else/ struct/ enum/ typedef
3>特征：都是小写、Xcode中显示紫褐色
============================二、标识符===================
1>程序中自定义的一些符号和名称
2>命名：最好取一个有意义的名字、多个单词使用驼峰标识
1).只能由26个英文字母的大小写、10个阿拉伯数字0~9、下划线_组成
2).严格区分大小写，比如test和Test是2个不同的标识符
3).不能以数字开头
4).不可以使用关键字作为标识符
============================三、注释=======================
1>注释可以用来解释某一段程序或者某一行代码是什么意思，方便程序员之间的交流、注释可以是任何文字，也就是说可以写中文、在开发工具中注释一般是豆沙绿色//绿色
2>
1).单行注释以两个正斜杠开头，也就是以//开头
2).多行注释以/*开头，以*/结尾，/*和 */中间的内容都是注释
3>注释嵌套
1).单行注释可以嵌套单行注释、多行注释
// haha // hehe
// aagg /* hdhhd */ //jkkll
2).多行注释可以嵌套单行注释
/*
// 第一个C程序 */
3)多行注释不能嵌套多行注释(错误写法)
/* 第二个C程序
/* 哈哈 */
第三个C程序 */
4).注释例子
#include<stdio.h>// 这是一个main函数，//是整个程序的入口4353454//355345435
int main()
{
/* 这个函数可以往屏幕中输出 111 333
444 555 */
printf("111\n");
printf("333\n");
printf("444\n");
printf("555\n");
return0;
} // /*rewrewrwe*/
===============================四、数据类型======================
1>常量
1）.整型常量(int)：包括了所有的整数,如23、67、2、6
2）.浮点型常量(float(单精度浮点型)\double(双精度浮点型))：其中float以f结尾，如4.56f
3）.字符常量(char)：将一个数字（0~9）、英文字母（a~z、A~Z）或者其他符号（+、-、!、?等）用单引号括起来，这样构成的就是字符常量。比如'6'、'a'、'F'、'+'、'$'等
4）.字符串常量：将一个或者多个字符用双引号（""）括起来，这样构成的就是字符串常量，如"snckdj""C语言"
2>变量：当一个数据的值需要经常改变或者不确定时，就应该用变量来表示
1).目的
a. 任何变量在使用之前，必须先进行定义
b. 定义变量的目的是：在内存中分配一块存储空间给变量，方便以后存储数据
c. 如果定义了多个变量，就会为这多个变量分别分配不同的存储空间
2).格式
变量类型变量名;
比如intnum;
a. 变量名属于标识符
b. 变量类型
c. 不同类型的变量占用不同大小的存储空间。内存极其有限，分配适当的存储空间
d. 约束变量所存放的数据类型（方便运算）
3).实例
int main(){
inti;
char c;
int a, b;
return0;
}
3>变量的使用
1).赋值：往变量里面存点东西，就是赋值。赋值语句后带个分号; a =1;
a. 第一次赋值，可以称为“初始化”
b. 初始化的两种形式
c. 先定义，后初始化：int a; a = 1;
d. 定义的同时进行初始化：int a = 1;
2).可以修改变量的值，多次赋值，每次赋值都会覆盖原来的值
int a = 1;
int b;
a = 2;
b = a;
变量a最后的值是2,b最后的值是2
4>变量的作用域：从定义变量的那行代码开始，一直到函数结束
1).错误写法:
int test(){
int score =200;
return0;
}
int main()
{
score = 100;//main函数中无变量score的定义
return0;
}
2).代码块的作用：及时回收不再使用的变量，为了提升性能
5>printf的输出
1).多个变量的输出
int a = 10, c = 11;printf("a=%d, c=%d", a, c);// %d是一个占位符
2).double\float\char的输出，格式符的一些小技巧
double height=1.55;char blood ='A';
printf("height=%.2f, 血型是%c", height, blood);// %.2f、%c是一个占位符2
3).简单的加减操作
int a = 10 + 20;4).变量没有初始化时不要拿来使用(下面的写法不建议)
int score;printf("score=%d", score);
6>习题(面试题)
交换整型变量a、b的值。比如a=10、b=11；交换之后a的值是11，b的值是10，用两种方式实现：
1).使用第三方变量
int temp;temp = a;
a = b;
b = temp;
2).不使用第三方变量
a = b - a;b = b - a;
a = b + a;
7>变量的内存分析
1).内存以“字节为单位”
2).所占用字节数跟类型有关，也跟编译器环境有关,以64位编译器为例：
char1个字节、int4个字节、float4个字节、double8个字节
3).变量实例
int b = 10;int a = 20;
内存由大到小寻址，优先分配内存地址较大的字节给变量，b的内存地址比a大
每个变量都有地址：第一个字节的地址就是变量的地址
4).查看内存地址：
a. 输出地址的占位符为p%
b. 取得变量的地址：&变量名
int a;printf("a的地址是：%p\n",&a);
============================五、scanf函数=========================
1>这是在stdio.h中声明的一个函数，因此使用前必须加入#include <stdio.h>，调用scanf函数时，需要传入变量的地址作为参数，scanf函数会等待标准输入设备（比如键盘）输入数据，并且将输入的数据赋值给地址对应的变量
2>基本使用
int age;
scanf("%d", &age);
a. scanf函数时，会等待用户的键盘输入，并不会往后执行代码。scanf的第1个参数是"%d"，说明要求用户以10进制的形式输入一个整数。这里要注意，scanf的第2个参数传递的不是age变量，而是age变量的地址&age，&是C语言中的一个地址运算符，可以用来获取变量的地址
b. 输入完毕后，敲一下回车键，目的是告诉scanf函数我们已经输入完毕了，scanf函数会将输入的值赋值给age变量
3>用scanf函数接收多个数值，每个数值之间可用分隔符隔开，如：
scanf("%d-%d-%d",&a, &b, &c);// 输入格式为： 23-34-45scanf("%d,%d,%d",&a, &b, &c);// 输入格式：16,14,78
scanf("%d#%d#%d",&a, &b, &c);// 输入格式：10#14#20
// 可以是逗号、空格、tab、回车、*、井号#等等，甚至是英文字母
## 如果scanf参数中以空格隔开，实际输入可以以空格、tab、回车作为分隔符
4>注意
scanf的第一个参数中不要包含\n，比如scanf(“%d\n”,&a); 这将导致scanf函数无法结束
5>习题：提示用户输入两个整数n，然后计算并输出两个整数的和
#include<stdio.h>int main()
{
int n1;
int n2;
// 1.提示用户输入两个正整数，以空格隔开
printf("请输入两个正整数，以空格隔开:\n");
// 2.接收用户输入的正整数
scanf("%d %d",&n1, &n2);
// 3.输出
printf("n1 + n2 = %d\n", n1+ n2);
return0;
}
*********************基本运算******************
## C语言一共有34种运算符，包括了常见的加减乘除运算
====================一、算术运算================
1>加法运算+
除开能做加法运算，还能表示正号：+5、+90
2>减法运算-
除开能做减法运算，还能表示符号：-10、-29
3>乘法运算*
注意符号，不是x，而是*
4>除法运算/
注意符号，不是÷，也不是\，而是/
整数除于整数，还是整数。1/2的值是0，这个并不是二分之一
5>取余运算%
什么是取余：两个整数相除之后的余数
%两侧只能是整数
正负性取决于%左侧的数值(注意)
6>注意点
1).自动类型转换(double->int)
int a = 10.6;int b = 10.5 +1.7;
自动将大类型转换为了小类型，会丢失精度
2).自动类型提升(int->double)
int b = 10.5 +10; // 将右边的10提升为了double类型double b =1.0 / 2; // 因等号左边是double类型，算数符号左或右转换成double类型，另外一个会自动换成 double类型..
3).强制类型转换(int->double)
double a = (double)1/ 2;double b = (double)(1/ 2);// 参与运算是什么类型，得出的结果就是什么类型，整数除以整数的结果还是整数
4). %两侧必须是整数
int b = 10 % 2;int c = 10.0 %2; // 错误写法..
7>运算顺序
1).同类型，从左至右：2+3+4
2）.优先级，乘除大于加减：5+4*8-3
8>习题：提示用户输入一个时间的秒数，比如500秒输入500，然后输出对应的分钟和秒，比如500s就是8分钟20秒
#include <stdio.h>int main()
{
// 1.定义一个变量储存用户输入的秒数
int second;
// 2.提示用户输入一个秒数
printf("请输入一个秒数：\n");
// 3.接收用户输入的秒数
scanf("%d",&second);
printf("%d分钟%d秒\n", second/60,second%60);
return0;
}
=====================二、赋值运算符===================
1>简单赋值
1).int a =10 + 5;的运算过程
2).a = b= 10;的运算过程
3).等号左边不能是常量，比如10 =11;
2>复合赋值
复加减乘除余：a += 4 + 5;
=====================三、自增自减===================
1>简单使用
1).++ 自增运算符。如a++，++a，都等价于a = a+1
2).自减运算符。如a--，--a，都等价于a = a-1
3).5++是错误的
2> ++a和a++的区别
1).int a =10;
2).a++; ++a;
3).int b =a++; int b =++a;
3>使用注意
1）.b =a++; // a参与运算的值是a加了1之前的值，a先参与运算，再加1
2）.b =++a; // a参与运算的值是a加了1之后的值，a先加1，再参与运算
1->b =(a++) + (++a); //结果为 a = 12 b = 22
2->b =(++a) + (a++); //结果为 a = 12 b = 22
=====================三、sizeof===================
1>作用
用来计算一个变量或者一个常量、一种数据类型所占的内存字节数。
2>基本形式
1).sizeof( 变量\常量 )
2).sizeof( 数据类型 )
int size = sizeof(10);int size = sizeof10.9;
int size = sizeof(a);
int size = sizeof a;
int size = sizeof(char);
//int size = sizeof char; // 错误写法
=====================四、关系运算符===================
1> C语言规定，任何数值都有真假性，任何非0值都为“真”，只有0才为“假”。也就是说，108、-18、4.5、-10.5等都是“真”，0则是“假”
2>关系运算符的运算结果只有2种：如果条件成立，结果就为1，也就是“真”；如果条件不成立，结果就为0，也就是“假”
3>使用注意
1). 关系运算符中==、!=的优先级相等，<、<=、>、>=的优先级相等，且前者的优先级低于后者：2==3>1
2). 关系运算符的结合方向为“从左往右”：4>3>2
3). 关系运算符的优先级小于算术运算符：3+4>8-2
=====================四、逻辑运算符===================
1>&&逻辑与
1). 使用格式
“条件A&&条件B”
2). 运算结果
只有当条件A和条件B都成立时，结果才为1，也就是“真”；其余情况的结果都为0，也就是“假”。因此，条件A或条件B只要有一个不成立，结果都为0，也就是“假”
3). 运算过程
总是先判断条件A是否成立
a. 如果条件A成立，接着再判断条件B是否成立：如果条件B成立，“条件A&&条件B”的结果就为1，即“真”，如果条件B不成立，结果就为0，即“假”
b. 如果条件A不成立，就不会再去判断条件B是否成立：因为条件A已经不成立了，不管条件B如何，“条件A &&条件B”的结果肯定是0，也就是“假”
4). 举例
逻辑与的结合方向是“自左至右”。比如表达式 (a>3)&& (a<5)
a. 若a的值是4：先判断a>3，成立；再判断a<5，也成立。因此结果为1
b. 若a的值是2：先判断a>3，不成立，停止判断。因此结果为0
c. 因此，如果a的值在(3, 5)这个范围内，结果就为1；否则，结果就为0
5). 注意
a. 若想判断a的值是否在(3, 5)范围内，千万不能写成3<a<5，因为关系运算符的结合方向为“从左往右”。比如a为2，它会先算3<a，也就是3<2，条件不成立，结果为0。再与5比较，即0<5，条件成立，结果为1。因此3<a<5的结果为1，条件成立，也就是说当a的值为2时，a的值是在(3,5)范围内的。这明显是不对的。正确的判断方法是：(a>3)&& (a<5)
b. C语言规定：任何非0值都为“真”，只有0才为“假”。因此逻辑与也适用于数值。比如5&&4的结果是1，为“真”；-6&&0的结果是0，为“假”
2> || 逻辑或
1). 使用格式
“条件A || 条件B”
2). 运算结果
当条件A或条件B只要有一个成立时（也包括条件A和条件B都成立），结果就为1，也就是“真”；只有当条件A和条件B都不成立时，结果才为0，也就是“假”。
3). 运算过程
总是先判断条件A是否成立
a. 如果条件A成立，就不会再去判断条件B是否成立：因为条件A已经成立了，不管条件B如何，“条件A || 条件B”的结果肯定是1，也就是“真”
b. 如果条件A不成立，接着再判断条件B是否成立：如果条件B成立，“条件A || 条件B”的结果就为1，即“真”，如果条件B不成立，结果就为0，即“假”
4). 举例
逻辑或的结合方向是“自左至右”。比如表达式 (a<3) ||(a>5)
a. 若a的值是4：先判断a<3，不成立；再判断a>5，也不成立。因此结果为0
b. 若a的值是2：先判断a<3，成立，停止判断。因此结果为1
c. 因此，如果a的值在(-∞, 3)或者(5, +∞)范围内，结果就为1；否则，结果就为0
5). 注意
C语言规定：任何非0值都为“真”，只有0才为“假”。因此逻辑或也适用于数值。比如5 ||4的结果是1，为“真”；-6 ||0的结果是1，为“真”；0 ||0的结果是0，为“假”
3> ! 逻辑非
1). 使用格式
“! 条件A”
2). 运算结果
其实就是对条件A进行取反：若条件A成立，结果就为0，即“假”；若条件A不成立，结果就为1，即“真”。也就是说：真的变假，假的变真。
3). 举例
逻辑非的结合方向是“自右至左”。比如表达式 ! (a>5)
a. 若a的值是6：先判断a>5，成立，再取反之后的结果为0
b. 若a的值是2：先判断a>3，不成立，再取反之后的结果为1
因此，如果a的值大于5，结果就为0；否则，结果就为1
4). 注意
a. 可以多次连续使用逻辑非运算符：!(4>2)结果为0，是“假”，!!(4>2)结果为1，是“真”，!!!(4>2)结果为0，是“假”
b. C语言规定：任何非0值都为“真”，只有0才为“假”。因此，对非0值进行逻辑非!运算的结果都是0，对0值进行逻辑非!运算的结果为1。!5、!6.7、!-9的结果都为0，!0的结果为1
5). 优先级
a. 逻辑运算符的优先级顺序为：小括号() >负号 - >! >算术运算符>关系运算符>&&> ||
b. 表达式!(3>5) || (2<4)&& (6<1) ：先计算 !(3>5)、(2<4)、(6<1)，结果为1，式子变为1 || 1&&0，再计算1&&0，式子变为1 ||0，最后的结果为1
c. 表达式3+2<5||6>3等价于 ((3+2) <5) || (6>3)，结果为1
d. 表达式4>3&&!-5>2等价于 (4>3)&& ((!(-5)) >2) ，结果为0
4>三目运算符
1). 单目运算符-一个数据就可以搞定// !10
2). 双目运算符-两个数值搞定// 10>5
3). 三目运算符条件 ? 数值1 : 数值2// ! ?10 : 5
4). 三目运算如果条件成立就返回数值1，如果条件不成立就返回数值2
5>例子
#include <stdio.h>int main()
{
// 计算3个整数之间的最大值
int a =10;
int b = 999999;
int c = 1000;
//分步骤求出最大值可读性较高....推荐写法....
// 求出a、b的最大值
int abMax =(a> b) ? a : b;
// 求出最终的最大值
int d =(abMax> c) ? abMax: c;
//int d = (((a > b) ? a : b) > c) ? ((a > b) ? a: b) : c;//可读性极差，不建议写这样的代码
printf("d is %d\n", d);
return0;
}