《初识C语言二(注释&字符串&转义字符&选择循环语句&函数&数组&操作符》

作者:小泽同学~
csdn个人主页:小泽同学~
码云：classmate-mzq
蘭motto:己所不欲，勿施于人and勿以善小而不为，勿以恶小而为之
————————————————

前言：不出意外的话，我将在这里记录我的大学编程学习。
因为我也是小白，所以如果大家看到问题的话，可以直接在下面评论或者加我v私我，感谢大家！
个人v：m0106gm(添加的话麻烦备注csdn）
祝我们前程似锦

本人使用的开发环境工具是vs2022

---

文章目录

• 1.注释
• 2.字符串
• 3.转义字符
• 4.选择语句
• 5.循环语句
• 6.函数
• 7.数组
• 8.操作符
• 8.关键字

1.注释

1. 代码中有不需要的代码可以直接删除，也可以注释掉
2. 代码中有些代码比较难懂，可以加一下注释文字（！这是我们添加注释的最主要的原因，解释复杂的代码，方便以后自己修改或其他人看懂你在写什么）

注释有两种风格（这里说风格，也就是说比较常用，但是无论什么编程语言俩种注释方法都是可行的）：

• C语言风格的注释
  缺陷：不能嵌套注释
• C++风格的注释 //xxxxxxxx
  可以注释一行也可以注释多行

int main()
{
	//int a=10;   //c++注释风格
	          //c语言注释风格
	return 0;
}

//   ————不支持嵌套，例如下面的操作会报错： 
          //c语言注释风格
	return 0;
}
*/

2.字符串

int main()
{
	"hdjah";
	"123jhaj";
	"Hello Worldn";
	return 0;
}

定义：“hdjah”,“1213jhaj”,“Hello Worldn”,这种由双引号引起来的一串字符称为字符串字面值，或者简称字符串。
注：字符串的结束标志是一个的转义字符。每一个字符串的结尾都隐藏了一个字符作为结束标记，只是表面上你看不到。在计算字符串长度的时候 是结束标志，不算作字符串内容。

清晰的认识到的作用1.0，知识储备>

1. 数组：可以存放同种数据类型的数据类型
   字符数组：可以存放各种字符的数据类型
   字符数组定义：char a[];其中，char[ ]是字符数组类型，a是变量名。
2. 字符数组初始化：char a[]="Hello";orchar a[]={'H','e','e','l','o'};
3. 打印字符串：打印字符串的格式字符为%s,即printf("%s",a);输出Hello

#include 
int main()
{
	char arr1[] = "hello";
	char arr2[] = { 'h','e','l','l','o' };
	printf("%sn", arr1);
	printf("%sn", arr2);
	return 0;
}

猜猜看会打印什么？

是不是完全没有想到啊！这就是的作用体现了：
事实上，第一种初始化的方法，它会在后面默认添上,即第一种初始化后arr1里面的内容其实是hello,而第二种初始化后arr2的内容就只是hello,所以当我们打印数组arr1时，当它打印到就停止了，而当我们打印数组arr2时，我们并不清楚hello后面的内容是什么，所以打印hello后后面的内容完全是随机的，直到它遇到了,才停止打印。

而如果我们这样做，即主动在数组arr2里面添一个:

#include 
int main()
{
	char arr1[] = "hello";
	char arr2[] = { 'h','e','l','l','o',''};
	printf("%sn", arr1);
	printf("%sn", arr2);
	return 0;
}

打印：

清晰的认识到的作用2.0，知识储备>
函数strlen:： 作用：求字符串的长度，即传入一个字符串，会返回这个字符串的长度
使用方法：需要引用头文件string,即这样：#include

#include 	 //使用了函数printf
#include   //使用了函数strlen
int main()
{
	char arr1[] = "hello";  //初始化数组arr1
	char arr2[] = { 'h','e','l','l','o',};  //初始化数组arrr2
	//定义俩个整型变量用来存放函数strlen的返回值，即字符串的长度
	int a1 = 0, a2 = 0;  
	a1 = strlen(arr1);
	a2 = strlen(arr2);
	printf("%dn", a1);
	printf("%dn", a2);
	return 0;
}

一样，猜猜会打印什么呢？

如果你猜对了，那你真是。。。赶快去买彩票吧。

---

函数strlen，当它遇到时结束计算，返回字符串的长度，而上面一开始也说了：计算字符串长度的时候是结束标志，不算作字符串内容。
因此数组arr1输出打印5，表面arr1的长度为5，理所当然，arr1就包含了"hello"5个字符嘛。那么数组arr2呢？：是一个随机值！我们并不清楚数组arr2中hello后面的内容是什么，所以strlen会一直计算下去，直到它遇到了,才停止并返回字符串的长度。

#include 	 
#include   
int main()
{
	char arr1[] = "hello";  
	char arr2[] = { 'h','e','l','l','o',''}; //主动添一个''
	char arr3[] = "helloworld"; //字符数组中间有''
	int a1 = 0, a2 = 0,a3=0;  
	a1 = strlen(arr1);
	a2 = strlen(arr2);
	a3 = strlen(arr3);
	printf("%dn", a1);
	printf("%dn", a2);
	printf("%dn", a3);
	return 0;
}

打印：

3.转义字符

首先向大家出一个题目，你们能打印出“c:rodetest.c”吗？试试看吧>

//你们是不是这样写代码的呢？：
#include 	  
int main()
{
	printf("c:rodetest.c");
	return 0;
}

???这是什么情况，怎么打印出这玩意出来？
这里就不得不提一下转义字符了。转义字符顾名思义就是转变意思。
下面看一些转义字符。

上面的转义字符，有些只需要知道就好，用的很少很少，所以这里作者只讲几个重点且能让大家更理解转义字符的意义的：

1. a蜂鸣或响铃字符，试试看这样写代码printf("%c",'a');,你能听到电脑发出的熟悉的声音
2. 换行符,不用多说了吧，用的最多的，作用就是在打印代码的时候让打印的代码换行
3. r,回车，作用就是把它后面的东西移到本行最前面
   这就是为什么上面的代码会这样打印的原因之一
4. 水平制表符t(跳到下一个tab位置）：其实就是相当于你键盘是的Tab键
   这就是为什么上面的代码会这样打印的原因之一
5. \代表一个反斜线,理解很简单，就是为了让计算机知道这就是一个单纯的,不然如果你单纯只写一个,它可能会跟后面的字符连在一起形成一个转义字符。
   所以如果你想要打印c:rodetest.c，需要这样printf("c:\rode\test.c")
6. '代表一个单引号，如果你想打印一个单引号，也许你会这样printf("%c",''')，此时编译器会报错，因为它会默认把前面俩个单引号匹配，而第三个单引号就是孤立的。所以如果想打印一个单引号，需要这样printf("%c",''');
7. """代表一个双引号，同理，如果你想打印一个双引号，也许你会这样printf("%s",""")，此时编译器会报错，因为它会默认把前面俩个双引号匹配，而第三个双引号就是孤立的。所以如果想打印一个双引号，需要这样printf("%s",""");
8. ddd表示1~3个八进制数字所代表的字符
9. xdd表示1~2个十六进制数字所代表的字符

！ddd和xdd是重点
要理解ddd和xdd需要先了解一下八进制数和十六进制数以及ASCIl表

所谓八进制就是逢8进1，十六进制就是逢16进1，我们通过十进制来认识。

十进制就是我们生活中用得最多的进制：0，1，2，3，4，5，6，7，8，9，十个数字，当我们计算3+9时，此时计算结果大于10，逢10进1，进1位，余下的数保持原位，则结果为12。计算52+69时，2+9大于10则进一位，余1，5+6+1（其中1是进位来的）大于10进1，余2，所以结果为121

同理，在八进制中，0，1，2，3，4，5，6，7，八个数字，计算6+7而用八进制进行输出时则输出15，逢8进1，6+7大于8，进1位，余下5，所以结果为15

同理，在十六进制中，0，1，2，3，4，5，6，7，8，9，A,B,C,D,E,F，16个数字或字母来表示，（其中字母即可用大写也可用小写）A表示10，B表示11，F表示15，当计算12+2而以十六进制进行输出时，结果为e或E，计算34+12时以十六进制输出时为2d或2D，因为34+12=46，46/16=2···14，14为d

八进制和十六进制转化成十进制是多少呢？
十进制转化成十进制是怎么转化的：十进制数245=2*10²+4*10¹+5*10⁰=2*100+4*10+5*1=245
八进制数130=十进88 (1*8²+3*8¹+0*8⁰=64+24+0=88)
十六进制数45=十进制数69 (4*16¹+5*16⁰=64+5=69)

//接下来我们这样写代码试试看
#include 	  
int main()
{
	printf("%c",'130');
	return 0;
}

//输出打印：
X

上面说了ddd代表一个八进制数字，130转化成十进制数后就是88,88对应的ASCII表字符就是x。
下面是ASCII表：

为什么有ASCII表？
我们键盘上有许多字符，&8*hs$5%#@?等等，而计算机是以二进制的形式进行存储的，所以为了存储这些字符，我们规定每一个字符都对应一个数字，并制成了ASCII表

#include 	  
int main()
{
	printf("%c",'x30');
	return 0;
}

//输出打印：
0

x30代表十六进制数30，转化成十进制数则为48，（3*16¹+0=48),48对应的ASCII码值就是0

提问：c:test628test.c的长度是多少？
上一篇《初始c语言一》中提到过了求字符串的函数strlen，所以我们来尝试一下

#include 	  
#include    //使用了函数strlen需要引用头文件string.h
int main()
{
	printf("%d",strlen("c:test628test.c"));
	return 0;
}

输出打印：
14

哈哈，我想算对的人应该很少很少吧，为什么是14呢？
正确的分法应该是这样：c:test628test.c

1. t现在能理解了吧，它们合起来算一个转义字符
2. 有问题的可能就是这里了：628,为什么它是俩个字符而不是一个呢？因为ddd代表的是八进制数，而八进制没有数字8啊!（八进制数（0，1，2，3，4，5，6，7）所以理所当然计算机把62当成一个八进制数代表的字符，而·8则单独算一个字符。
   哈哈，是不是踩坑了

4.选择语句

这里只是初识，只要知道就好，具体的用法之后会细讲

if语句，根据条件判断真假而进行不同的操作

if(条件正确)  //如果
{
	执行代码；
}
else if（条件正确） //否则如果
{
	执行代码；
}
else            //否则
{
	执行代码；
}

#include 	  
int main()
{
	int a = 10, b = 23;
	if (a > b)
	{
		printf("a比b大n");
	}
	else if(a
		printf("a比b小n");
	}
	else
	{
		printf("a跟b相等n");
	}
	return 0;
}

#include 	  
int main()
{
	int input = 0;//创建一个变量用来存放输入的值；
	printf("你要努力学习（1）还是摆大烂（0）？请选择>n");
	scanf("%d", &input);  //输入
	if (input == 1)   //这里一定是要有俩个=（原因以后会讲）
	{                   //如果input是1则进行下面的代码
		printf("可以获得好offer，加油！n");
	}
	else           //否则的话就进行下面的代码
	{
		printf("卖红薯赚钱去n");
	}
	return 0;
}

5.循环语句

这里只是初识，只要知道就好，具体的用法之后会细讲

1.while语句
2.for 语句（以后讲）
3.do…while语句（以后讲）

while 语句的基本逻辑

while (条件)
	{
		如果符合条件的话执行代码；
	}

#include 	  
int main()
{
	int a = 1;
	while (a < 10)  //条件
	{
		printf("%d你好n", a);  //执行代码
		a = a + 1;      //条件变化
	}
	return 0;
}

6.函数

我们熟悉的数学中的函数f(x)=x²+2x+3，x值不同f(x)也就跟着变化，f(x,y)=2x+y也同理
而计算机也有函数，也能够进行这样的运算

求两个数的和，应该怎么打代码？

#include 	  
int main()
{
	int a = 0, b = 0;     //定义俩变量
	scanf("%d %d", &a, &b);   //输入
	int sum = a + b;     //求和
	printf("%d", sum);    //打印
	return 0;
}

利用函数怎么打代码呢？

函数原型：
返回类型 函数名（参数类型 参数名，。。。）
{
	函数体
}
例：求俩个整数的和的函数
int add(int x,int y)    
{
	int z=x+y;
	return z;
}
//int是返回类型，因为函数是求俩个整数的和，那么返回的值就是俩个整数的和，返回值也是整数
//add是函数名
//int x,int y是参数，需要传入多少个值就需要多少个参数
//z是返回值，计算出来后通过return返回

#include 	  
int add(int x, int y)
{
	int z = x + y;
	return z;
}
int main()
{
	int a = 0, b = 0;
	scanf("%d %d", &a, &b);
	int sum = add(a, b);
	printf("%d", sum);
	return 0;
}

7.数组

问：当你想要存储1-10的数字，怎么存储？
难到需要这样？：

int a = 1;
int b = 2;
int c = 3;
...
...

显然可不能，太麻烦了，因此产生了数组》
C语言中给了数组的定义：一组相同类型元素的集合

数组的定义：
int arr[10] = {1,2,3,4,5,6,7,8,9,10};//定义一个整形数组，最多放10个元素
char ch[3]={'a','b','c'};//定义一个字符数组，最多放3个元素
另：int arr[10] = { 1,2,3 };   //未完全初始化，其他的值会默认初始为0

数组的下标
C语言规定：数组的每个元素都有一个下标，下标是从0开始的。
数组可以通过下标来访问的。

#include 	  
int main()
{
	int arr[10] = { 1,2,3, };
	int i = 0;
	while (i < 10)
	{
		printf("%dn", arr[i]); //通过数组下标访问，数组的第一个元素下标为0
		i = i + 1;
	}
	return 0;
}

8.操作符

只需要知道就好，之后细讲，后面学习的时候遇到就会知道了。

1. 算术操作符   
	 + - * / %
2.移位操作符 	 
	>> <<
2. 位操作符 
	 & ^ | 
3. 赋值操作符  	
=  +=  -=  *=  /=  %=  ^=   |=    >>=   <<=
4. 单目操作符	
!           逻辑反操作
-           负值
+           正值
&           取地址
sizeof      操作数的类型长度（以字节为单位）
~           对一个数的二进制按位取反
--          前置、后置--
++          前置、后置++
*           间接访问操作符(解引用操作符)
(类型)       强制类型转换
5. 关系操作符
>
>=
<
<=
!=      用于测试“不相等”
==      用于测试“相等”
6. 逻辑操作符
&&     逻辑与
||     逻辑或
7. 条件操作符
exp1 ? exp2 : exp3
8. 逗号表达式
exp1, exp2,.......expn
9. 下标引用、函数调用和结构成员
[] () . ->

• 加减乘除：+ - * /

//+-*就不说了，直接用
#include 	  
int main()
{
	int a = 0, b = 0;
	scanf("%d %d", &a, &b);
	printf("a+b=%dn", a+b);
	printf("a-b=%dn", a - b);
	printf("a*b=%dn", a * b);
	//但如果是除法呢？打一个代码，计算10处于4吧
	printf("10/4=%dn",10/4);
	return 0;
}

10/4,打印出来的是2！是的，’/‘号的计算结果算出来的就是整数而已，如果想要精确出小数，就需要使用浮点型:

#include 	  
int main()
{
	double a = 0, b = 0;
	scanf("%lf %lf", &a, &b);
	printf("%lf",a/b);
	return 0;
}

• % ——取余

#include 	  
int main()
{
	printf("%d",10%3);//输出1，10除以3余1
	return 0;
}

• 赋值操作符

#include 	  
int main()
{
	int a = 10;
	a += 2;    //相当于a=a+2
	printf("%d", a);//输出12
	return 0;
}

同理，a-=3相当于a=a-3;a*=4相当于a=a*4;a/=5相当于a=a/5;'%’等也是一样。。。

• 单目运算符

什么叫单目运算符？就是作用对象只有一个，像加减乘除就是双目运算符’a+b’,有俩个对象，单目运算符只有一个：

1. ‘-’：负号,a=-20;
2. 'sizeof':计算类型或变量的大小:sizeof是一个操作符同时也是一个关键字，sizeof不是函数！

//sizeof不是函数的证明：
#include 	  
int main()
{
	int a = 10;
	printf("%dn", sizeof(a));   //可以
	printf("%dn", sizeof(int));  //；可以
	printf("%dn", sizeof a)   //可以 
	printf("%dn", sizeof int);  //报错
return 0
}

3. ‘！’：逻辑非，在编程语言中，0代表假，非0为真；比如下面的代码：

#include 	  
int main()
{
	int a = 10;
	if (a)  //a不等于0，条件为真
	{
		printf("hihi");
	}
	return 0;
}

此时只要a不等于0，都会打印“hi hi”

#include 	  
int main()
{
	int a = 10;
	if (!a)    //a=10,逻辑非后即!a就等于0
	{
		printf("hihi");
	}
	return 0;
}

此时只要a不是0，都不会打印，只有a为0时，才会打印

4. ++and--(分前置和后置）

#include 
int main()
{
	int a=10;
	printf("%dn",a);
	printf("%dn",a++);
	printf("%dn",a);
	printf("%dn",++a);
	printf("%dn",a);
	printf("%dn",a--);
	printf("%dn",a);
	printf("%dn",--a);
	printf("%dn",a);
	return 0;
}

打印

原因：前置++和–，进行了+1和-1，但是表达式的结果还是原来的值，只有再次打印才能输出+1或-1后的值，后置++和–进行了+1和-1，表达式的值就是结果值
即如果a=5,a++这个表达式的值仍是5，而++a的值就是6

5. 条件操作符exp1?exp2:exp3 ,这其实也是一个表达式，如果exp1正确，表达式的结果为exp2的结果，如果exp2错误，则表达式的结果为exp3的结果

#include 
int main()
{
	int a=10,b=34;
	int max=(a>b?a:b);  
	printf("%d",max);
	return 0;
}

打印34

6. 逗号操作符exp1, exp2,exp3... expN
   计算顺序：从左往右，结果等于最后一个表达式的结果

#include 
int main()
{
	int a=2,b=3,c=5,ret=0;
	ret=(a+=5,b-=a,c*=b);   //从左往右依次计算，a=7,b=-4,c=-20
	printf("%d",ret);   
	return 0;
}

打印-20

7. 下标引用[]、函数调用()

#include 
int main()   //main就是一个函数
{
	int a[5]={1,2,3,4,5};
//下标引用用于数组
	printf("%d",a[3]);  // printf也是函数，中间用（）括号括起来
	return 0;
}

打印4（数组下标从0开始）

• 关系操作符

大于等于小于等就不说了
说一下不等于’!=‘和等于’==‘，此时你应该知道为什么等于需要俩个‘=‘了，因为一个’=‘其实是赋值的意思，完全不一样，所以判断两个数是否相等的时候一定是用 ==,’!为逻辑非，’!='就是不等于的意思咯

#include 	  
int main()
{
	int a = 10;
	if (a == 10)   //判断是否等于是一定是用'=='
	{
		printf("正确");
	}
	return 0;
}

8.关键字

auto break case char const continue default do double else enum exterm float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while

1. 关键字是C语言提供的，不能自己创建关键字
2. 变量不能用关键字命名

关键字不需要死记，以后学得多了，用的时候自然会记住
所以这里也先不讲