C语言操作符

目录

 操作符分类：

算术操作符

移位操作符

位操作符

赋值操作符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

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

---

1.算数操作符

+  -  *  /  %

1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。

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

3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。

2.移位操作符

位移操作符处理的是内存中的二进制序列

数据在内存中储存的是二进制补码

对于正数而言 ， 源码，反码，补码相同

对于负数而言 ， 反码 为源码符号位不变，其他位按位取反，

                            补码 为反码 + 1

符号位为最高的一位，1为负，0为正

<< 左移操作符

>> 右移操作符

ps 操作符处理的类型只能是整形变量。

2.1左移操作符

使用规则：左边丢弃，右边补0

n<<1

ps  因为操作的是n的二进制序列，n 在没有被赋值的情况下并没有变化。

3.2右移操作符

a.算数右移  右边丢弃，左边按符号位补齐

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

a.算数右移

n>>1

 打印到屏幕上的应该是源码，而不是反码！！！

b.逻辑右移

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

int n=4;

n>>-1; X 标准未定义

3.位操作符

& // 按位与

| // 按位或

^ // 按位异或

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

位操作符处理的也是内存中的二进制补码

&      两个位同时为1时才为1

|        两个位同时为0时才为0

^       相同为0，相异为1

 举栗子

//交换两个数字的值
int main()
{
	int a = 2;
	int b = 5;
	printf("交换前：a=%d b=%d\n", a, b);
	a = a ^ b;
	b = a ^ b;//a^b ^b
	a = a ^ b;//a^ a^b
	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}

 

注意： a^a=0  0^a=a

//求一个整数存储在内存中的二进制中1的个数。
#include <stdio.h>
int main()
{
	int num = -1;
	int i = 0;
	int count = 0;//计数
	while (num)
	{
		count++;
		num = num & (num - 1);// & 同时为1时才为1
                    //减1 是二进制位的运算
	}
	printf("二进制中1的个数 = %d\n", count);
	return 0;
}

-1在内存中的二进制补码为

11111111111111111111111111111111

4.赋值操作符

int a;
a=5;//把5赋值给a

复合赋值符

+=

-=

*=

/=

%=

>>=

<<=

&=

|=

^=

这些运算符都可以写成复合的效果

5.单目操作符

类别

!           逻辑反操作

-           负值

+           正值

&           取地址

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

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

--           前置、后置 --

++           前置、后置 ++

*           间接访问操作符 ( 解引用操作符 )

( 类型 )       强制类型转换

!           逻辑反操作

#include<stdio.h>

int main()
{
	int a = 0;
	if (a)
		printf("666\n");
	else
		printf("wot\n");
	if (!a)
		printf("???\n");
	return 0;
}

 

 可见 若a为真则 !a 为假，反之亦然

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

#include<stdio.h>
int main()
{
	int a = 12;
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(int));
	printf("%d\n", sizeof a);//这样写行不行？
	return 0;
}

由此可见sizeof为操作符而非函数

printf ( "%d\n" , sizeof int ); // 这样写行不行？

答案是不行的

数组与sizeof

数组名代表首元素地址，但是有两种情况是特例

1.sizeof(arr)//计算的是整个数组的大小单位是字节

2.&arr//求的是整个数组的地址

#include <stdio.h>
void test1(int arr[])
{
	printf("%d\n", sizeof(arr));//?
}
void test2(char ch[])
{
	printf("%d\n", sizeof(ch));//?
}
int main()
{
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	printf("%d\n", sizeof(arr));//?
	printf("%d\n", sizeof(ch));//?
	test1(arr);
	test2(ch);
	return 0;
}

输出的结果是？？

#include <stdio.h>
void test1(int arr[])//传递的是首元素地址
{
	printf("%d\n", sizeof(arr));//4 
}
void test2(char ch[])//传递的是首元素地址
{
	printf("%d\n", sizeof(ch));//1
}
int main()
{
	int arr[10] = { 0 };//int  4个字节
	char ch[10] = { 0 };//char 1个字节
	printf("%d\n", sizeof(arr));//40
                                4*10=40
	printf("%d\n", sizeof(ch));//10
                                1*10=10
	test1(arr);
	test2(ch);
	return 0;
}

++ 和 -- 运算符

前置++ 和 --

先加减后使用

后置++ 和--

先使用后加减

//前置++ 和 --
#include <stdio.h>
int main()
{
    int a = 10;
    int x = ++a;
    //先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。
    int y = --a;
    //先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;
    return 0; }

//后置++和--
#include <stdio.h>
int main()
{
    int a = 10;
    int x = a++;
    //先对a先使用，再增加，这样x的值是10；之后a变成11；
    int y = a--;
    //先对a先使用，再自减，这样y的值是11；之后a变成10；
    return 0; }

6.关系操作符

>

>=

<

<=

!=   用于测试 “ 不相等 ”

==       用于测试 “ 相等 ”

警告：

在编程的过程中 == 和 = 不小心写错，导致错误

所以用  5==a  代替  a==5

7.逻辑操作符

&&     逻辑与

||           逻辑或

a&&b

a,b 同时为真则为真，若a为假则为假，且表达式b 不再参与运算

a||b

a,b,中同时为假则为假，若a为真，则表达式b不参与运算

举个栗子

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

​

输出结果为 1 2 3 4

原因：上方下划线

8.条件（三目）操作符

exp1?exp2:exp3

之前博文提及

9. 逗号表达式

exp1, exp2, exp3, …expN

逗号表达式，就是用逗号隔开的多个表达式。

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

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

 从左到右依次计算   a=12  b=13  根据逗号表达式可知c =13

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

下标引用操作符 [ ]

操作数：一个数组名 + 一个索引值

int arr [ 10 ]; // 创建数组

arr [ 9 ] = 10 ; // 实用下标引用操作符。

[ ] 的两个操作数是 arr 和 9 。

 ( ) 函数调用操作符

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

#include<stdio.h>
int Add(int x, int y)
{
	int z = x + y;
	return z;
}
int main()
{
	int a = 2, c = 3;
	int sum = Add(a,c);//函数调用操作符
	printf("%d\n", sum);
	return 0;
}

 访问一个结构的成员

. 结构体 . 成员名

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

#include<stdio.h>
struct stu
{
	char name[10];
	int age ;
}s;
int main()
{
	
	struct stu s = { "张三",10 };
	printf("%s %d\n", s.name, s.age);
	return 0;
}

#include<stdio.h>
struct stu
{
	char name[10];
	int age ;
};
int main()
{
	
	struct stu s = { "张三",10 };
	struct stu* sp = &s;
	printf("%s %d\n", sp->name,sp->age );
	return 0;
}

 

11表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。

同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。

11.1 隐式类型转换

C 的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为 整型 提升 。

整型提升的意义 ：

表达式的整型运算要在 CPU 的相应运算器件内执行， CPU 内整型运算器 (ALU) 的操作数的字节长度

一般就是 int 的字节长度，同时也是 CPU 的通用寄存器的长度。

因此，即使两个 char 类型的相加，在 CPU 执行时实际上也要先转换为 CPU 内整型操作数的标准长

度。

通用 CPU （ general-purpose CPU ）是难以直接实现两个 8 比特字节直接相加运算（虽然机器指令

中可能有这种字节相加指令）。所以，表达式中各种长度可能小于 int 长度的整型值，都必须先转

换为 int 或 unsigned int ，然后才能送入 CPU 去执行运算。

char a,b,c;
a=b+c;

b和c的值被提升为普通整型，然后再执行加法运算。

加法运算完成之后，结果将被截断，然后再存储于a中。

如何进行整体提升呢？

整形提升是按照变量的数据类型的符号位来提升的

// 负数的整形提升

char c1 = - 1 ;

变量 c1 的二进制位 ( 补码 ) 中只有 8 个比特位：

1111111

因为 char 为有符号的 char

所以整形提升的时候，高位补充符号位，即为 1

提升之后的结果是：

11111111111111111111111111111111

// 正数的整形提升

char c2 = 1 ;

变量 c2 的二进制位 ( 补码 ) 中只有 8 个比特位：

00000001

因为 char 为有符号的 char

所以整形提升的时候，高位补充符号位，即为 0

提升之后的结果是：

00000000000000000000000000000001

// 无符号整形提升，高位补 0

举个栗子

int main()
{
 char c = 1;
 printf("%u\n", sizeof(c));
 printf("%u\n", sizeof(+c));
 printf("%u\n", sizeof(-c));
 return 0; }

结果为1，4，4

sizeof计算的是表达式的大小，只要c参与运算就会发生整型提升，sizeof虽然不会计算表达式，但要知道表达式的类型

11.2算数转化

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类 型，否则操作就无法进行。下面的层次体系称为寻常算术转换 。

long double

double

float

unsigned long int

long int

unsigned int

int

如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。

注意

float f = 3.14 ;

int num = f ; // 隐式转换，会有精度丢失

11.3 操作符的属性

复杂表达式的求值有三个影响的因素。

1. 操作符的优先级

2. 操作符的结合性

3. 是否控制求值顺序。

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。

操作符优先级

从上到下依次递减

问题表达式

// 表达式的求值部分由操作符的优先级决定。

a * b + c * d + e * f

注释：代码 在计算的时候，由于 * 比 + 的优先级高，只能保证， * 的计算是比 + 早，但是优先级并不

能决定第三个 * 比第一个 + 早执行。

所以会出现歧义

我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题

的。