C语言初阶-操作符详解（1）

已于 2023-10-27 20:24:40 修改
阅读量223 收藏
点赞数
文章标签： c语言 开发语言
于 2023-09-06 17:51:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/syh163/article/details/132700800
版权

目录

1.操作符分类：

2.算数操作符

3.移位操作符

>>  右移操作符

<<  左移操作符

4.位操作符

&    按位与 

|     按位或

^    按位异或

位操作符的使用示例：

5.赋值操作符

6.单目操作符

！  逻辑反操作

&   取地址和 *    间接访问操作符（解引用操作符）

sizeof   操作数的类型长度（以字节为单位）

~    对一个数的二进制按位取反

 前置、后置--和前置、后置++

 （类型）强制类型转换 

7.关系操作符

8.逻辑操作符

1.操作符分类：

算数操作符、移位操作符、位操作符、赋值操作符、单目操作符、关系操作符、逻辑操作符、条件操作符、逗号操作符、下标引用、函数调用和结构体成员

2.算数操作符

+     -    *     /      %

 加减乘都很简单，下面主要介绍除法 /  和取余 % 

 /  除法：

1.整数除法（除号两端都是整数）

2.浮点数除法（除号两端只要有一个小数就执行小数除法）

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 7 / 2;
	printf("%d\n", a);
	return 0;
}

上述代码运行结果是：3。因为除号两端都是整数，所以进行整数除法，7/2=3余1，结果保留整数2。这时有人说了，要得到3.5不是要用浮点型进行接收吗？

下面我们来实验一下：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 7 / 2;
	printf("%d\n", a);
	double b = 7 / 2;
	printf("%lf\n", b);
	return 0;
}

运行结果：

结果我们可以看到还是3，所以说不管我们用什么类型，只要除号两端的数都是整数，它计算的结果都是只保留整数部分的结果。那么我们要怎么得到小数呢？

只需将除号两端的数中的任意一个改成小数就可以了：

上图将7改为7.0，最终结果变为3.5。当然也可以将2改为2.0。

注意：除法中，除数不能为0。否则编译器会报错：

  % 取余：得到的是整除后的余数。

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int b = 19 % 5;
	printf("%d\n", b);
	return 0;
}

以上代码结果为：4。因为18/5=3余4，%操作符得到的结果就是余数4。

注意：取余操作符的两个操作数必须都是整数。

3.移位操作符

<<  左移操作符

>>  右移操作符

注： 移位操作符的操作数只能为整数

移位操作符移动的是二进制的信息。因为计算机识别的都是二进制数，我们在输入十进制数或者其他进制的数时，在计算机中都是以二进制存储的。

学过计算机的应该都知道，整数的二进制表示形式有三种：原码、反码和补码。

正整数的原码、反码、补码是相同的。而负整数的原码、反码、补码是要计算的。

首先不管是正整数还是负整数都可以写出二进制原码

1.根据正负直接写出的二进制序列就是原码

例如：int  a = 15;

a写成二进制就是：1111。因为1个整型是4个字节 = 32bit位，a为正整数，所以a的原码、反码和补码用二进制表示为：00000000000000000000000000001111

其中最高位是符号位：

那 int b = -15，b的原码就是 10000000000000000000000000001111

而负数的反码是符号位不变，其他位按位取反：11111111111111111111111111110000

负数的补码是在它的反码的基础上加1:11111111111111111111111111110001

注意：整数在内存中存储的是补码，所以计算的时候也是用补码，比如我们一会要说的移位就是在补码上操作的。

移位移动的是补码的二进制序列。

>>  右移操作符

在学习右移操作符之前我们要知道右移有两种：
1.算数右移：右边丢弃，左边补原来的符号位

2.逻辑右移：右边丢弃，左边补0

C语言没有明确规定使用算数右移还是逻辑右移，但是一般编译器使用的是算数右移

下面我们看一段代码：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 15;
	int b = a >> 1;
	printf("%d\n", b);
	printf("%d\n", a);

	return 0;
}

运行结果： 


 

上述代码中a = 15经过右移一位后得到的结果是7。下面我们来分析一下为什么会得到7：

因为a是正数，它的原码、反码和补码都是：00000000000000000000000000001111

经过算数右移后变为：00000000000000000000000000000111，输出十进制数就得到了7

以上是正整数的移位操作，下面我们来看一下负整数的移位操作，它们的移位过程是否一样呢？

看下面的一段代码及运行结果：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = -15;
	int b = a >> 1;
	printf("%d\n", b);
	return 0;
}

运行结果为：-8。

我们先写出-15的原码二进制表示形式：10000000000000000000000000001111（负数符号位为1）

将-15的原码转换为补码为：11111111111111111111111111110001

将其补码右移一位：11111111111111111111111111111000

我们知道在内存中存储的是补码的二进制形式，但是在打印输出时用的是原码，所以再将右移后的补码转换为原码的二进制表示为：10000000000000000000000000001000，输出十进制数就得到了-8。

这里再补充说明一下负数的补码化为原码的两种方法：

方法1  由于负数的原码转化为补码的过程是，将其原码除符号位以外的其他位取反再加一，那么负数的补码转化为原码的过程完全可以反向进行，即将补码先减一，再将除符号位的其他位取反。

方法2  直接将负数的补码除符号位以外的其他位取反再加一，这样也可以得到原码。

<<  左移操作符

左移操作符的规则很简单：左边丢弃，右边补0

下面我们看一段代码：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 6;
	int b = a << 1;
	printf("%d\n", b);
	return 0;
}

运行结果：12。

因为a是正整数，原、反、补码都是：00000000000000000000000000000110

左移一位补码为：00000000000000000000000000001100，

原码同补码：00000000000000000000000000001100，输出十进制数就得到12。

注意：对于移位操作符来说，不要移动负数位，这是标准未定义的。

4.位操作符

&         按位与

|           按位或

^          按位异或

注：位操作符的操作数必须为整数

&    按位与 

看下面一段代码：
 

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 3;
	int b = -5;
	int c = a & b;
	printf("%d\n", c);
	return 0;
}

运行结果：3

在计算机中a的补码为：00000000000000000000000000000011

b的补码为：11111111111111111111111111111011

按位与的规则是：对应的二进制位只要有一个为0，则按位与后的结果为0，两边同时为1，按位与后的结果才为1

那么a&b的补码就是：00000000000000000000000000000011

化为原码：00000000000000000000000000000011，输出十进制数就得到3

|     按位或

看下面一段代码：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 3;
	int b = -5;
	int c = a | b;
	printf("%d\n", c);
	return 0;
}

运行结果：-5

在计算机中a的补码为：00000000000000000000000000000011

b的补码为：11111111111111111111111111111011

在计算机中按位或的规则是：对应的二进制位只要有一个1按位或后的结果就是1，两边同时为0，按位或的结果才为0

那么a | b的补码用二进制表示为：11111111111111111111111111111011

化为原码：10000000000000000000000000000101，输出十进制数为-5

^    按位异或

看下面一段代码：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 3;
	int b = -5;
	int c = a ^ b;
	printf("%d\n", c);
	return 0;
}

运行结果：-8

在计算机中a的补码为：00000000000000000000000000000011

b的补码为：11111111111111111111111111111011

在计算机中按位异或的规则是：对应的二进制位相同为0，相异为1

那么a^b的补码用二进制表示为：11111111111111111111111111111000

化为原码：10000000000000000000000000001000，输出十进制数为-8

位操作符的使用示例：

1.规定不能创建临时变量，实现两数的交换

前面我们学过交换两个变量的值，通过创建临时变量tmp实现：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	printf("交换前：a=%d b=%d\n", a, b);
	int tmp = a;
	a = b;
	b = tmp;
	printf("交换后：a=%d b=%d\n",a,b);
	return 0;
}

那如果规定不能创建临时变量，如何实现两数的交换？

这时就要用到我们的按位异或操作符 ^ 了。

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	printf("交换前：a=%d b=%d\n", a, b);
	a = a ^ b;
	b = a ^ b;
	a = a ^ b;
	printf("交换后：a=%d b=%d\n",a,b);
	return 0;
}

运行结果：

这就是代码实现啦，具体过程可以根据按位异或的规则自己分析一下。

下面还有几种常见的使用方法：

a ^ a = 0         a ^ 0 = a      a ^ b ^ a = a ^ a ^ b = b（异或满足交换律）

这个也可以用来解释上述代码：将a = a ^ b带入b = a ^ b得到b = (a ^ b) ^ b = a

然后将a = a ^ b和b = a代入a = a ^ b得到a = (a ^ b) ^ a = b，这样就实现了两数的交换。

2.编写代码实现：求一个整数存储在内存中的二进制中的1的个数

直接看代码：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 0;
	int count = 0;
	scanf("%d", &a);
	int i = 0;
	for (i = 0; i < 32; i++)
	{
		if ((a>>i) & 1 == 1)
		{
			count++;
		}
	}
	printf("%d\n", count);
	return 0;
}

任何数和1相与就能得到它的最低位，比如5&1，如下图：

我们要求一个整数存储在内存中的二进制中的1的个数，就要知道它的补码的每一位，任何数和1相与都能得到最低位，那我们每次将这个整数向右移1位再和1相与就能得到这个整数的每一位，然后写if语句判断每一位是否等于1，满足条件计数器加一，又因为整数在计算机中有32个bit位，外面再写for循环直到将32位每一位都判断完就结束循环，如此以来就实现了题目要求。

5.赋值操作符

= 

复合赋值操作符：

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

  赋值操作符很好用，他可以将你不喜欢的值进行修改。初始化一个变量的值不是你想要的，那就可以在后面用赋值操作符进行修改。

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 10;
	a = 20;
	printf("%d\n", a);
	return 0;
}

上述代码初始化a为10，下面可以将a重新赋值位20，最终输出的也是20.

复合赋值操作符用法都相似，这里只说一下+=，其他的与之用法相同

看下面一段代码：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 10;
	a +=  1;
	printf("%d\n", a);
	return 0;
}

运行结果：11

由此可见，a += 1;和a = a + 1;的效果一样，前者可以看做是后者的一种简写方式。

以此类推，-=，*=，/=，.......与其用法相似。

6.单目操作符

单目操作符只有一个操作数

！        逻辑反操作

-           负值

+          正值

&          取地址

sizeof   操作数的类型长度（以字节为单位）

~           对一个数的二进制按位取反

--           前置、后置--

++         前置、后置++

*            间接访问操作符（解引用操作符）

（类型）强制类型转换 

！  逻辑反操作

逻辑反操作符的作用就是将真的变成假的，假的变成真的

比如下面代码中的两个if语句的作用都是一样的：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 0;
	if (a == 0)
	{
		printf("hehe\n");
	}
	if (!a)
	{
		printf("hehe\n");
	}
	return 0;
}

运行结果：

第一个if语句是当满足a=0的时候执行，第二个if中a=0为假，而!a将其变为真，也执行了if语句，其作用就是当a为假时，打印hehe。

-、+这两个操作符很简单，就不多讲了。

&   取地址和 *    间接访问操作符（解引用操作符）

这两个都用于指针，可以放在一块讲。

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 10;
	//pa是指针变量
	int* pa = &a;//&-取地址操作符-取出a的地址
	*pa = 20;//解引用操作符（间接访问操作符）-单目操作符-通过pa中存放的地址，找到其指向的空间（内容）
	printf("%d\n", a);
	return 0;
}

运行结果：20

代码中&a是取出a的地址，pa是指针变量，用来存放a的地址，而*pa=20是通过pa中存放的地址，找到其存放的a的值并将其改为20.

sizeof   操作数的类型长度（以字节为单位）

注意：sizeof是操作符不是函数，sizeof计算的是类型创建变量的大小，以字节为单位

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 10;
	printf("%d\n", sizeof(int));
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof a);
	return 0;
}

运行结果：

由此可证明sizeof计算的是类型创建变量的大小，以字节为单位

它既可以通过类型计算大小（sizeof(int)），也可以通过变量计算大小（sizeof(a)）。

sizeof 后面跟变量时也可以不用带括号，由此可证明sizeof确实不是函数，因为我们在使用函数时都是要带括号的。

我们在前面也学过用sizeof计算数组的大小，如下：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%d\n", sizeof(arr));
	return 0;
}

运行结果：40

因为数组中有10个元素，每个元素都是int型，4个字节，所以数组大小为40个字节

同样我们也可以通过类型计算数组的大小，数组的类型是：int [10]（即去掉数组名arr）

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	printf("%d\n", sizeof(int [10]));//通过类型计算数组大小
	return 0;
}

~    对一个数的二进制按位取反

看下面代码：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 0;
	printf("%d\n", ~a);
	return 0;
}

运行结果：-1

为什么是-1呢？

a在计算机中二进制表示形式为：00000000000000000000000000000000

~a在计算机中二进制表示形式为：11111111111111111111111111111111，这是补码，转化为原码为：10000000000000000000000000000001，输出十进制数为-1。

那学完~操作符，我们就可以来举一个示例了：

题目：要求把13的第五位二进制改成1，其他位不变

要实现只将第五位给为1，其他位不变，给它或上00000000000000000000000000010000就行，而00000000000000000000000000010000可以通过将1左移4位得到。

代码实现：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 13;
	a |= (1 << 4);
	printf("%d\n", a);
	return 0;
}

运行结果：29。即（00000000000000000000000000011101）

同样也可以通过按位取反操作符~将其还原：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 13;
	a |= (1 << 4);
	a &= (~(1 << 4));
	printf("%d\n", a);
	return 0;
}

运行代码：13。

在这里按位取反操作符还可以应用于多组输入类问题：

下面是前面我们学习的多组输入的写法：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 0;
	while (scanf("%d", &a) != EOF)//scanf读取失败返回EOF
	{
		printf("%d\n", a);
	}
	return 0;
}

上面代码可以实现多组输入，下面我们可以用按位取反操作符来实现多组输入类问题：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 0;
	while (~scanf("%d", &a))
	{
		printf("%d\n", a);
	}
	return 0;
}

那原理是什么呢？

因为读取失败返回EOF，而EOF相当于-1（我们可以右击EOF点击查看定义看到），而前面加~，-1就变成0,0为假，循环结束。所以只要没有读取失败，就会多组输入，直到读取失败返回EOF。

 前置、后置--和前置、后置++

前置++：先自增，再使用

后置++：先使用，后自增

前置++：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 3;
	int b =++a;//先自增为4，然后赋值给b
	printf("a=%d b=%d\n",a, b);
	return 0;
}

运行结果：

后置++：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = 3;
	int b =a++;//先赋值给b，再自增为4
	printf("a=%d b=%d\n",a, b);
	return 0;
}

运行结果：
 前置、后置--和前置、后置++  的用法相似，不再多讲。

 （类型）强制类型转换 

给变量初始化的值与其类型不符时，为了避免警告就可以用强制类型转换来实现。

如下，初始化时将整型a的值初始化为3.14，为了避免警告，此时使用强制类型转换

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int a = (int)3.14;
	return 0;
}

注意：强制类型转换时将类型写在括号里，例：int a = (int)3.14;

int a = int(3.14);这种写法是错误的。

7.关系操作符

> 

>= 

< 

<= 

!=       用于测试“不相等”

==      用于测试“相等”

8.逻辑操作符

&&        逻辑与

||           逻辑或

 逻辑与就相当于“并且”，逻辑或就相当于“或者”

逻辑与必须&&两边的条件同时满足才能执行后面程序

逻辑或||两边的条件满足其中一个就能执行后面程序

前面我们讲过的判断闰年就是典型的例子：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int f = 0;
	scanf("%d", &f);
	//1.能被4整除，并且不能被100整除
	//2.能被400整除是闰年
	if (f % 4 == 0 && f % 100 != 0 || f % 400 == 0)
	{
		printf("是闰年\n");
	}
	else
	{
		printf("不是闰年\n");
	}
	return 0;
}

   下面来看一个例题：

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++ && ++b && d++;
	printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);
	return 0;
}

   打印出来的结果是什么呢？

为什么是这个结果呢？

因为a++,先使用a=0的值，再将a自增，而逻辑与左边为假，右边就不计算了，所以后面的++b和d++都没有执行。

那我们换成逻辑或看打印结果是否会发生变化呢？

#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int main()
{
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++ || ++b || d++;
	printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);
	return 0;
}

运行结果：

为什么是这个结果呢？

因为逻辑或左边为真，右边就不计算了，a++先将a=0的值和++b的值逻辑或，++b的值是3为真，逻辑或的结果为真，后面的d++不再执行。所以结果是1,3,3,4

注意：逻辑操作符计算结果为真，使用1表示。计算结果为假，使用0表示。

今天就学到这里，未完待续。。。                                                                        

成屿
关注
C语言初阶-操作符详解（2）
syh163的博客
09-07 289
exp1?前面我们学过像a+b这样有两个操作数的表达式，+有两个操作数，称为双目操作符；像！a这样有一个操作数的，！只有一个操作数，称为单目单目操作符。今天我们要学的条件操作符有三个操作数，我们把它称作。那么它的作用是什么呢？上述条件操作符中有三个表达式，exp1、exp2、exp3.其实我们可以看出来条件操作符的作用就相当于一个 if....else语句我们也可以用条件操作符来实现前面学过的求两数的较大值。
C语言初阶——操作符详解
m0_53485626的博客
01-18 777
C语言操作符，一看就懂！！！
C语言操作符（运算符）详解
lzf的博客
12-15 698
操作符2000字详解
临时变量的引用和常量引用（类型转换造成临时变量的生成）
diaoergiao的博客
04-06 987
常量引用是不能修改所引用的值的，但是初始化的时候其所引用的对象并不一定非要是一个常量对象，因为常量引用的目的是确保不会通过这个引用变量来修改你所引用的值，但是并不代表这个值不能通过其他方式进行修改，比如可以通过他本身进行修改 #include <iostream> using namespace std; void test01() { int a = 10; const int& b = a; //b = 2;//报错，常量引用不能修改 a = 13;//可以自己修改自己的值
c++中临时变量不能作为非const的引用参数
一碗米线
02-05 1万+
引自：http://blog.baisi.net/?116670/viewspace-4407 试看下面的代码： #include using namespace std; void f(int &a)  {  cout } void g(const int &a) {  cout }  int main()  {  int a = 3, b = 4;
C++ | 引用变量
热门推荐
cccccccj
03-22 3万+
目录 目录 导语：为什么要有引用变量 引用的概念 用法示例 引用的属性与特别之处 主要作用 1.引用作参数 用法 引用传参的另一个好处 小结 2.引用作返回值 为何要返回引用 返回引用时要注意的问题 小结 何时使用引用参数 1. 传递值而不修改值(尽量 const 修饰) 2. 需要修改原数据 实现方法（汇编层来看） 导语：为什么要有引用变量 拿一个...
【C语言初阶】 操作符
小王又困了的博客
05-16 486
符合赋值符 += 、 -= 、 *= 、 %= 、 >>= 、
【C语言】初阶，操作符解析（一）
qq_67808901的博客
06-24 370
c语言操作符详解。
C语言的视频的配套课件 包含了C语言初阶和进阶
06-26
17. C语言操作符详解（1） 18. C语言操作符详解（2） 19. 初始指针（1） 20. 初始指针（2） 21.作业讲解（1） 22. 作业讲解（2） 23. 初始结构体 24. VS环境-C语言实用调试技巧（1） 25. VS环境-C语言实用调试技巧...
【C语言初阶】操作符
weixin_65174108的博客
12-09 242
一般就是int的字节长度，同时也是CPU的通用寄存器的长度。如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。刚讲到了-1在内存中是以补码的形式储存的，在内存中正数的原码反码补码是相同，而负数在内存中存储的是补码。实例3中的，c只要参与表达式运算，就会发生整形提升，表达式 +c ，就会发生提升，所以sizeof(+c) 是4个字节。知，+操作符的左操作数的获取在右操作数之前的值还是之后求得的值，所以结果是不可预测的，是有歧义的。
C++之非const引用无法绑定临时变量原因(一百三十六)
Android系统攻城狮
02-12 822
因为字符串"hello"是const类型,所以string &类型也为const,改为: const string &;这样左值const string &就可以接收"hello"字符串常量。在print("hello")中，"hello"为字符串常量，为const类型;所以无法将左值的非const的string&绑定右值的const 类型"hello"。第二种方法：改为：print(const string& str);第一种方法：string buf = "hello";
C语言学习笔记—P13（操作符详解＜1＞+图解+题例）
m0_57859086的博客
11-13 1266
目录 前言：●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！ ——By 作者：新晓·故知 操作符详解<1>：​ 题例： 1. 操作符分类： 算术操作符 移位操作符 位操作符 赋值操作符 单目操作符 关系操作符 逻辑操作符 条件操作符 逗号表达式 下标引用、函数调用和结构成员 2. 算术操作符 ......
c++中不能返回临时变量的引用或者指针的问题
weixin_32737733的博客
12-05 1643
例1： int f() { 　　int i = 1； 　　return i; } int main { 　　int r = f(); } 在例1的程序中，由于f()函数返回的是int类型，在函数结束时，要返回的值已经用于初始化函数的调用点的临时量了（假设为temp，在main(调用者)中），函数执行完后，i确实是被销毁了，但是temp还没有被销毁。int r= f()语句相当于执行：int r =...
【C++】C++引用 （引用不会？详细解决引用诸多细节！）
小羊study_sheep的博客
09-07 2677
c++引用，里面有好多图解，可以点进来看看！
【C语言精讲】——操作符的用法
Zincy星辰
12-11 1125
详细讲解了C语言中各类操作符的使用规则与方法。
临时变量 引用参数和const
m0_73265646的博客
02-01 444
何种情况下，c++将生成临时变量，以及如何使用const引用。
C语言的输入输出和运算符
m0_59173154的博客
02-26 4613
输入输出 1.标准输入输出头文件 #include<stdio.h> 2.调节控制台的大小 控制台右键，属性 3.printf():在控制台上显示数据 Int printf(“cintrol string”,argamentlist); 返回类型为int ①Printf（）：包含控制字符串和参数列表 控制字符串包括：文本字符，空格，格式命令，非打印字符（转义字符：\r回车，\n换行，\0空字符，\t制表符） ②格式命令：由%开头，%d，%c，%f，%lf，%..
C语言从头学65—学习头文件 ＜stdio.h＞（一）
最新发布
m0_72128260的博客
10-08 340
stdio.h是我们接触最早的头文件，用于读取和写入文件，也用于控制台的输入和输出。这个头文件中的《标准 I/O 函数》、《文件操作函数》、《字符串操作函数》前面已经学习过。这里继续学习一些没有使用过的函数。
2021 年 12 月青少年软编等考 C 语言二级真题解析
学习过程的记录与分享。
10-02 1170
2021 年 12 月青少年软编等考 C 语言二级真题解析。
"C语言基础-操作符详解：算数与移位操作符
C语言基础-操作符详解 一、引言 在C语言中，操作符是一种用来执行特定操作的标识符。操作符可以用于执行算术运算、逻辑运算、位运算等。本文将详细介绍C语言中的操作符，并围绕算术操作符和移位操作符进行详细的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

成屿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值