ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

操作符--小小操作符功能却很强大

2021-12-20 11:58:01  阅读：205  来源： 互联网

标签：小小 main return -- int 操作符 printf include


文章目录

算术操作符：

+ - * / %

\1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数
% 操作符的两个操作数必须为整数。返回的是整除之后的余数
%操作符的被除数不能是0，否则就会报错

#include <stdio.h>
int main()
{
	printf("%d", -99 % 0);
	return 0;
}

img2、对于 / 操作符如果两个操作数都为整数,执行整数除法.而只要有浮点数执行的就是浮点数除法

#include <stdio.h>
int main()
{
	printf("%d", 3/2);//打印出来的结果为1，因为是整型除法所以要用%d打印，%f打印出来为0.0000000
	return 0;
}

#include <stdio.h>
int main()
{
	printf("%f", 3.0/2);//或3/2.0或3.0/2.0，结果为1.500000，默认精度为6位
//因为是浮点数除法所以用的是%f，如果用%d打印结果为0
	return 0;
}

移位操作符：

<< 左移操作符
>> 右移操作符

注：移位操作符的操作数只能是整数，移动的是二进制位

原码反码补码

首先我们了解一个知识点

计算机中内部存储数字用的是补码

**一个整数的二进制表示有3种：**原码，反码，补码

我们规定正数的原反补码三码合一，都是一样的

对于负数的原反补码

假如int a = -1；int为四个字节

原码：直接根据数值写出的二进制序列
00000000000000000000000000000001
反码：原码的符号位不变，其他位按位取反
011111111111111111111111111111111110
补码：反码+1
011111111111111111111111111111111111

<< 左移操作符（移动的是补码）

左边丢弃，右边补0

#include <stdio.h>
int main()
    int a = 1;
	printf("%d", a << 2);
//00000000000000000000000000000001
//00000000000000000000000000000100
//左边丢失，右边补0，向右移2位，所以打印出来结果为4
	return 0;
}

>> 右移操作符（移动的是补码）

右移操作符有两种位移方式

1、算数位移

右边丢弃，左边补原符号位的数字

2、逻辑位移

右移丢失，左边补0

#include <stdio.h>
int main()
{
	int a = -1;
	printf("%d", a >> 2);
//打印出来结果还是-1
//说明在这个编译器进行的是算数位移
	return 0;
}

注：在a是有符号整型的负数时，位移运算的结果因编译器而异，在许多编译器会进行逻辑运算或者算数运算，不要对负数位移，无论采用哪种方式都会降低程序的可移植性

注：a<<-5标准未定义，会产生未知结果，所以要写成a>>5

位操作符：

& 按位与 按（补码二进制）位与
| 按位或 按（补码二进制）位与
^ 按位异或 按（补码二进制）位与

注：他们的操作数必须是整数

& //按位与

规则：1与1为1,1与0和0与0都为0

#include <stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	int c = a & b;
	printf("%d", c);//打印结果为0
	return 0;
}
//a的二进制位00000000000000000000000000000001
//b的二进制位00000000000000000000000000000010
//c的二进制位00000000000000000000000000000000

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RjuxfyfD-1639971909492)(data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==)]

| 按位或

规则：1与1和1与0为1,0与0为0

#include <stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	int c = a | b;
	printf("%d", c);//打印的结果为3
	return 0;
}
//a的二进制位00000000000000000000000000000001
//b的二进制位00000000000000000000000000000010
//c的二进制位00000000000000000000000000000011

^ 按位异或

规则：1与1和0与0为0，只有1与0为1

#include <stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	int c = a ^ b;
	printf("%d", c);//打印的结果是3
	return 0;
}
//a的二进制位00000000000000000000000000000001
//b的二进制位00000000000000000000000000000010
//c的二进制位00000000000000000000000000000011

赋值操作符：

= （+= -= *= /= %= >>= <<= &= |= ^=）复合赋值赋

赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值

int a = 1;

a=20;//将a赋值

赋值操作符可以连续使用：

int a = 10;
int x = 0;
int y = 20;
a = x = y+1;//连续赋值
//将y+1的值赋给x，再将x赋给a

不过为了方便调试我们一般把赋值拆开来写

int a = 10;
int x = 0;
int y = 20;
x = y+1;
a = x;//这样代码看着简洁很多

复合赋值符+=，其余效果差不多，不做过多介绍

int x = 10;
x = x+10;
x += 10;//使代码看着更加简洁

单目操作符：

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

! 逻辑反操作

将真(非0)变成假(0)，假(0)的变成真(非0，默认为1)

#include <stdio.h>
int main()
{
	int a = !0;
	printf("%d", a);//结果为1
	return 0;
}

#include <stdio.h>
int main()
{
	int a = !1;
	printf("%d", a);//结果为0
	return 0;
}

-，+负值，正值

-1的话为负数，+1为正数，通常将正负省略

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

#include <stdio.h>
int main()
{
	int a = 10;
	printf("%p\n", &a);//%p打印的是地址，&a是获取a的地址，打印出来的是a的地址
	int* pa = &a;相当于int*pa; pa=&a；这里的*是指针的定义，是一个双目操作符
    //意思是定义一个int类型指针，然后用a的地址给p赋值；
	*pa = 20;//*pa的*为解引用操作符，通过*pa找到a的地址，然后将它赋值为20
	printf("%d", *pa);//打印出来为20
	return 0;
}

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

它的返回类型是无符号整型

#include <stdio.h>
int main()
{
	int a;
	printf("%d\n", sizeof a);//计算操作数的大小时候可以不用括号，打印结果为4
	printf("%d\n", sizeof(int));//计算数据类型大小时候必须要用括号，打印结果是4
	return 0;
}//这正能说明sizeof不是函数

我们再来深度了解一下sizeof操作符

#include <stdio.h>
void test1(int arr[])
{
printf("%d\n", sizeof(arr));//结果是4或者8，因为数组传参相当于传递了数组首元素的地址
}//相当于传递了一个指针int*arr，所以是4或者8
void test2(char ch[])
{
printf("%d\n", sizeof(ch));//结果是4或者8
}
int main()
{
int arr[10] = {0};
char ch[10] = {0};
printf("%d\n", sizeof(arr));//结果是40，因为int类型为4个字节，元素为10个，所以数组大小为40
printf("%d\n", sizeof(ch));//结果是10，因为char类型为1个字节，元素为10个，所以数组大小为10
test1(arr);
test2(ch);
return 0;
}

~ 对一个数的二进制按位取反（补码的二进制位）

全部位按位取反，包括符号位

#include <stdio.h>
int main()
{
	int a = 1;
	int b = ~a;
	printf("%d\n",b);//结果为-2,
    //a的补码为00000000000000000000000000000001
    //取反后b为11111111111111111111111111111110
    //得到b的原码的值为10000000000000000000000000000010
	printf("%d\n", a);//结果为1，说明取反不改变a的值
	return 0;
}

– 前置、后置–
++ 前置、后置++

前置是先自加1（或者自减1）再使用，后置是先使用再自加1（或者自减1）

#include <stdio.h>
int main()
{
	int a = 1;
	int b = 1;
	printf("%d\n", ++a);//结果为2，因为前置++是先自加1再使用
	a = 1;//将a赋值为1，因为++会改变a的值
	printf("%d\n", a++);//结果为1，因为后置++是先使用后自加
	printf("%d\n", --b);//结果为0，因为前置--是先自减1再使用
	b = 1;//将a赋值为1，因为--会改变a的值
	printf("%d\n", b--);//结果为1，因为后置--是先使用手自减1
	return 0;
}

**注：**该操作符会改变操作数的值

(类型) 强制类型转换

#include <stdio.h>
int main()
{
	int a = 3.14;
	printf("%d\n", a);//结果为3，虽然可以进行正常编译但是会出现警告
	return 0;
}

img

当我们使用int a = (int)3.14;

虽然结果还是3，但是警告会消失

关系操作符：

> >= < <= != ==

比较两个操作数的大小

注：在编程时候要注意不要将==与=写反了

逻辑操作符：

&& 逻辑与
|| 逻辑或

&& 逻辑与

必须操作符两边的操作数都是真，结果才是真

#include <stdio.h>
int main()
{
	printf("%d\n", 1&&0);//结果为0
	return 0;
}

#include <stdio.h>
int main()
{
	printf("%d\n", 1&&2);//结果为1
	return 0;
}

它可以控制求值顺序

#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);//打印的结果为1,2,3,4
  return 0;
}

这是因为a++&++b的时候，a已经为0了，后面的指令就没有继续执行了

|| 逻辑或

只要有一边为真结果就是真，只有当两边都是假才为假

#include <stdio.h>
int main()
{
	printf("%d\n", 1||0);//结果为1
	return 0;
}

#include <stdio.h>
int main()
{
	printf("%d\n", 0||0);//结果为0
	return 0;
}

它也可以控制求值顺序

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

当前a++||++b的时候，a++为真，后面的指令就没有执行了

条件操作符：

exp1 ? exp2 : exp3（也成为三目操作符）

当exp1为真时执行exp2，否则执行exp3

#include <stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	printf("%d\n",a>b?a:b);//结果为2，因为a>b为假，所以执行b
	return 0;
}

逗号表达式：

exp1, exp2, exp3, …expN

逗号表达式，就是用逗号隔开的多个表达式
逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果

#include <stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	int c = (a += a, b += a, c = a + b);
	printf("%d\n", c);//结果为6，结果为c=a+b的结果
	return 0;
}

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

[ ] 下标引用操作符

( ) 函数调用操作符

访问一个结构的成员：

**. 结构体.**成员名
**-> 结构体指针->**成员名

[ ] 下标引用操作符

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%d\n", arr[1]);//两个[]不是一个意思
	//第一个是创建数组时候的分隔符，第二个是下表引用操作符，用来通过数组的下标找到数组的元素
	//[]的操作数有两个，数组名和下标
	return 0;
}

( ) 函数调用操作符

接受一个或者多个操作数，第一个操作数是函数名，剩余的操作数就是传递给函数的参数

printf（"%d",10）;//printf为第一个操作数函数名

访问一个结构的成员：

. 结构体.成员名

#include <stdio.h>
struct person
{
	char name[20];
	int age;
	float weight;
    //name,age,weight为结构体成员名（结构体变量）
};//创建一个结构体

int main()
{
	struct person jake = { "jake",25,65.5 };//jake为结构体变量名
	printf("%s %d %.1f", jake.name, jake.age, jake.weight);
    //通过结构体变量名.结构体成员名来进行访问
    //打印出来的结果为jake 25 65.5
	return 0;
}

->结构体指针->成员名

#include <stdio.h>
struct person
{
	char name[20];
	int age;
	float weight;
};//创建一个结构体

int main()
{
	struct person jake = { "jake",25,65.5 };
	struct person* p = &jake;//创建一个结构体指针，将结构体jake的地址存入p中
	printf("%s %d %.1f", p->name, p->age, p->weight);//p指向的对象的name,age,weight
    //打印出来的结果为jake 25 65.5
	return 0;
}

标签：小小,main,return,--,int,操作符,printf,include
来源： https://blog.csdn.net/qq_45358642/article/details/122038160

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有