黑马程序员——C语言基础语法、基本运算理论

------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
142f4
;
}

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-45
scanf("%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;
}