1-3-初识C语言

目录

1. 数组

1.1 定义数组

1.2 数组的下标

1.3 数组的使用

2. *** 作符

算数 *** 作符

/ *** 作符

% *** 作符

移位 *** 作符

位 *** 作符

赋值 *** 作符

单目 *** 作符

关系 *** 作符

逻辑 *** 作符

条件 *** 作符（三目 *** 作符）

逗号表达式

下标引用、函数调用和结构成员

结语

---

1. 数组

要存储 1-10 的数字，怎么存储？

C语言中给出了数组的定义：一组相同类型元素的集合。

1.1 定义数组

#include 
int main()
{
	int a = 1; int b = 2; int c = 3; int d = 4;  //当定义多组相同类型的变量时，可以选择使用定义数组。
	int arr[10] = { 1,2,3,4};  //通过数组，可以定义一组相同类型的元素。
	char ch[5] = { 0 };  //不完全初始化，剩余会默认初始化为0.
	char ch1[] = { 'a','b','c','d' };  //自动开辟所需要的空间。
	char ch2[] = { 0 };  //只会开辟一个空间。
	return 0;
}

1.2 数组的下标

C语言规定：数组的每个元素都有一个下标，下标是从0开始的。

数组可以通过下标来访问的。

 数组内容可以通过下标访问

#include 
int main()
{
	int arr[10] = { 0 };
	printf("%d\n", arr[8]);
	printf("%d\n",arr[10]);  //由于下标范围是0-9,所以arr[10]属于越界访问行为
	return 0;
}
//--------------
//编译器编译结果为
//0
//- 858993460

越界访问可能会导致程序崩溃，程序出错等严重后果。

1.3 数组的使用

数组的输入和输出

#include 
int main()
{
	int i = 0;
	int arr[10] = { 0 };
	//输入10个值给数组
	while (i < 10)
	{
		scanf("%d", &arr[i]);
		i++;
	}
	i = 0;
	//输出10个值
	while (i < 10)
	{
		printf("%d\n", arr[i]);
		i++;
	}
	return 0;
}

2. *** 作符 算数 *** 作符

+        -        *        /        %（取余）

算数 *** 作符中 +  -  *  与平常运算相同，所以不做多解释，重点解释 / 和 % *** 作符。

/ *** 作符

#include 
int main()
{
	int a = 7 / 2;
	printf("%d\n", a);  //打印结果为3
	float b = 7 / 2;
	printf("%f\n", b);  //打印结果为3.000000
	float c = 7.0 / 2;
	printf("%f\n", c);  //打印结果为3.500000
	float d = 7.0 / 2.0;
	printf("%f\n", d);  //打印结果为3.500000
	return 0;
}

除号两端 *** 作数如果都是整数，执行整数的除法，至少有一个 *** 作数为浮点数，执行的才是浮点数除法

% *** 作符

#include 
int main()
{
	int a = 7 % 2;
	printf("%d", a);  //打印结果为 1
	int b = 7 % 2.0;  //加上此行代码会报错，%  *** 作符的两个 *** 作数必须是整数。
	return 0;
}

移位 *** 作符

>>（右移 *** 作符）        <<（左移操作符）

位 *** 作符

&（按位与）        ^（按位异或）        |（按位或）

移位 *** 作符和位 *** 作符以后讲解。

赋值 *** 作符

=     +=     -=     *=     /=     %=     >>=     <<=     &=     |=     ^=

由于赋值 *** 作符作用类似，不再依次举例。

#include 
int main()
{
	int a = 10;  //创建变量并初始化
	a = 20;  //进行赋值 *** 作
	a += 5;  //等价于a = a + 5
	printf("%d\n", a);  //打印结果为25
	a *= 5;  //等价于a = a * 5
	printf("%d\n", a);  //打印结果为125
    //剩余复合 *** 作符与+= *=  *** 作符用法类似，不做太多解释。
	return 0;
}

单目 *** 作符

例如：2+3，2为加 *** 作符的左 *** 作数，3为加 *** 作符的右 *** 作数，所以加 *** 作符是一个双目 *** 作符。

所以单目 *** 作符是只有一个 *** 作数的 *** 作符。

单目 *** 作符	含义
！	逻辑反 *** 作
-	负值
+	正值
&	取地址
sizeof	*** 作数的类型长度（以字节为单位）
~	对一个数的二进制按位取反
--	前置、后置 --
++	前置、后置 ++
*	间接访问 *** 作符 ( 解引用 *** 作符 )
（类型）	强制类型转换

！ *** 作符

#include 
int main()
{
	int a = 10;
	if (a)  //非零为真
	{
		printf("11");  //打印为11
	}
	if (!a)  //！ *** 作符使得真变假，假变真。
	{
		printf("22");  //不进行打印
	}
	return 0;
}

+ - *** 作符

+ - *** 作符改变值的正负

#include 
int main()
{
	int a = 10;
	printf("%d\n", +a);
	printf("%d\n", -a);
	return 0;
}
//-----------------
//编译器结果为
//10
//- 10

sizeof *** 作符

计算 *** 作数所占空间的类型大小，单位字节。

#include 
int main()
{
	int a = 10;
	char ch = 'a';
	int arr[10] = { 0 };
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(ch));
	printf("%d\n", sizeof(arr));
	return 0;
}
//---------------------
//编译器运行结果为
//4
//1
//40

计算数组元素个数

#include 
int main()
{
	int arr[10] = { 0 };
	int size = sizeof(arr) / sizeof(arr[0]);  //数组元素所占的总空间/单个元素所占空间=元素个数
	printf("%d", size);
	return 0;
}
------------
编译结果为
10

++ -- *** 作符

#include 
int main()
{
	int a = 10;
	int b = ++a;  //前置++，先++，后使用（赋值）
	printf("a=%d  b=%d\n", a, b);  //打印为a=11  b=11
	int c = 10;
	int d = a++;  //后置++，先使用（赋值），后++。
	printf("c=%d d=%d", c, d);  //打印为c=10 d=11
	return 0;
}

#include 
int main()
{
	int a = 10;
	int b = --a;  //前置--，先--，后使用（赋值）
	printf("a=%d  b=%d\n", a, b);  //打印为a=9  b=9
	int c = 10;
	int d = a--;  //后置--，先使用（赋值），后--。
	printf("c=%d d=%d", c, d);  //打印为c=10 d=9
	return 0;
}

（类型）  强制类型转换

#include 
int main()
{
	int a = 3.2;  //double类型转化为int，可能丢失数据。
	int b = (int)3.14;  //进行强制类型转换。
	printf("%d", b);  //打印结果为3，丢失数据。
	return 0;
}

关系 *** 作符

>（大于）   >=（大于等于）   <（小于）   <=（小于等于）   !=（不等于）   ==（等于）

#include 
int main()
{
	int a = 3;
	int b = 5;
	if (a != b)
	{
		printf("haha");  //打印haha
	}
	if (a == b)
	{
		printf("hehe");  //不打印
	}
	return 0;
}

逻辑 *** 作符

&&（逻辑与）        ||（逻辑或）

#include 
int main()
{
	int a = 3;
	int b = 0;
	if (a && b)  //a并且b为真时，为真
	{
		printf("haha\n");
	}
	int c = a && b;
	printf("%d\n", c);
	if (a || b)  //a或b，一个为真时，为真
	{
		printf("hehe");
	}
	return 0;
}

a&&b 当a、b同时为真时，整体为真，一个为假时，整体为假。（一假为假）

a||b 当a、b一个为真时，整体为真，a、b同时为假时，整体为假。（一真为真）

条件 *** 作符（三目 *** 作符）

exp1 ？ exp2 ：exp3

#include 
int main()
{
	int a = 10;
	int b = 0;
	if (a > 5)
	{
		b = 3;
	}
	else
	{
		b = -3;
	}
	return 0;
}

上述代码等价于b = (a > 5 ? 3 : -3);

当a大于5成立，则3为整个表达式的结果，否则-3为整个表达式的结果。

逗号表达式

exp1 , exp2 , exp3 ......expN

#include 
int main()
{
	int a = 3;
	int b = 5;
	int c = 0;
	int d = (a += 2, b = b - c + a, c = a + b);
	printf("%d\n", d);  //打印为15
	printf("a=%d b=%d c=%d", a, b, c);  //打印为a=5 b=10 c=15
	return 0;
}

逗号表达式特点：从左到右依次计算，整个表达式结果为最后一个表达式的结果。

下标引用、函数调用和结构成员

下标引用

[ ]  （下标引用 *** 作符）

#include
int main()
{
    int arr[10] = { 0 };
    arr[4] = 5;
    printf("%d", arr[4]);  //打印为5
    return 0;
}

数组建立和访问时出现的方括号即为下标引用 *** 作符。

函数调用

( )   （函数调用 *** 作符）

#include 
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int c = Add(2, 3);
	printf("%d", c);
	return 0;
}

Add函数后的圆括号，main函数，printf函数后的圆括号即为函数调用 *** 作符。

结构成员

结构成员涉及结构体，暂时不讲。

结语

好了，今天的初始C语言先分享到这里，希望我的博客能对大家有帮助。如果大家觉得菜菜写的还可以的话，请点赞+收藏哦！