潜学C语言——操作符

算术操作符

+  -  *  /  %

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

2.%的两个操作数必须为整数。

移位操作符

右移操作符：>> （有÷2的效果）
1.算术右移：右边丢弃，左边补原符号位
2.逻辑右移：右边丢弃，左边补0

int main()
{
int a = 16;
//>> -- 右移操作符
//移动的是二进制位
//00000000000000000000000000010000
int b = a >> 1;
printf("%d", b);
return 0;
}

int main()
{
int a = -1;
//整数的二进制表示有：原码，反码，补码
//存储到内存中的是补码
//10000000000000000000000000000001 -- 原码
//11111111111111111111111111111110 -- 反码
//11111111111111111111111111111111 -- 补码
int b = a >> 1;
printf("%d", b);
return 0;
}

左移操作符：<< （有×2的效果）

左边丢弃，右边补0
 

注：对于移位操作符，不要移动负数位，这个是标准未定义的。且只能作用于整数

位操作符

1. & 按位与

规则：

1&1=1

1&0=0

0&1=0

0&0=0

int main()
{
//& - 按2进制位与
int a = 3;
int b = 5;
int c = a & b;
//000000000000000000000000000000011 有一个是0就是0，两个都为1才是1
//000000000000000000000000000000101
//000000000000000000000000000000101
printf("%d", c);
return 0;
}

2. | 按位或

规则：

1|1=1

1|0=1

0|1=1

0|0=0

int main()
{
//| - 按2进制位或
int a = 3;
int b = 5;
int c = a | b;
//000000000000000000000000000000011 有一个是1就是1，两个都为0才是0
//000000000000000000000000000000101
//000000000000000000000000000000111
printf("%dn", c);
return 0;

^ 按位异或

规则：

1^1=0

1^0=1

0^1=1

0|0=0

int main()
{
//^ - 按2进制位异或
int a = 3;
int b = 5;
int c = a ^ b;
//000000000000000000000000000000011 相同为0，相异为1
//000000000000000000000000000000101
//000000000000000000000000000000110
printf("%dn", c);
return 0;
}

例：交换两个int变量的值，不能使用第三个变量。即a=3，b=5，交换后a=5，b=3

法一

int main()
{
int a = 3;
int b = 5;
a = a + b;
b = a - b;
a = a - b;
printf("a=%d b=%dn", a, b);
return 0;
}

法二：

int main()
{
int a = 3;
int b = 5;
a = a ^ b;
b = a ^ b;
a = a ^ b;
printf("a=%d b=%d", a, b);
return 0;
}

赋值操作符

=

复合赋值操作

复合赋值运算符有下列这些：

+= 加法赋值

-= 减法赋值

*= 乘法赋值

/= 除法赋值

%= 模运算赋值

<<= 左移赋值

>>= 右移赋值

&= 位逻辑与赋值

|= 位逻辑或赋值

^= 位逻辑异或赋值

单目操作符

a+b ：+双目操作符

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

！                逻辑反操作

-                  负值

+                 正值

&                 取地址

sizeof          操作数的类型长度

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

--                 前置、后置--

++                前置、后置++

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

（类型）     强制类型转换

例：sizeof

int main()
{
int a = 10;
char c = 'r';
char* p = &c;
int arr[10] = { 0 };
//sizeof计算变量所占内存空间的大小，单位是字节
printf("%dn", sizeof(a));//4
printf("%dn", sizeof(c));//1
printf("%dn", sizeof(p));//4
printf("%dn", sizeof(arr));//40
return 0;
}

int main()
{
short s = 0;
int a = 10;
printf("%dn", sizeof(s = a + 5));//short只能存两个字节
printf("%dn", s);//sizeof括号内的表达式不参与运算
return 0;
}

例 ：~

int main()
{
int a = 0;
//~按二进制位取反
//000000000000000000000000
//111111111111111111111111 -- 补码
//111111111111111111111110 -- 反码
//100000000000000000000001 -- 原码
printf("%dn", ~a);
return 0;
}

关系操作符

逻辑操作符

&& 逻辑与：两个表达式必须都为 true(非0)，整个表达式才为 true

||    逻辑或：必须有一个或两个表达式为 true，才能使整个表达式为 true。

！  逻辑非：使一个表达式从 true 变成了 false，或者从 false 变成了 true

int main()
{
int i = 0, a = 0 ，b = 2, c = 3,
d = 4;
i = a++ && ++b && d++;
printf("a=%dn b=%dn c=%dn d=%dn", a, b, c, d);
//a=1,b=2,c=3,d=4
return 0;
}

int main()
{
int i = 0, a = 1 ,b = 2, c = 3, d = 4;
i = a++ && ++b && d++;
printf(" a=%dn b=%dn c=%dn d=%dn", a, b, c, d);
//a=2,b=3,c=3,d=5
return 0;
}

int main()
{
int i = 0, a = 1 ,b = 2, c = 3, d = 4;
i = a++ || ++b || d++;
printf(" a=%dn b=%dn c=%dn d=%dn", a, b, c, d);
//a=2,b=2,c=3,d=4
return 0;
}

或者关系：左边为真，右边就不用计算

并且关系：左边为假，右边就不用计算了

注：&& (逻辑与) 优先级高于||（逻辑或）

条件操作符

exp1? exp2 ：exp3

(若exp1为真，则exp2要计算，否则exp3要计算)

int main()
{
int a = 0;
int b = 0;
if (a > 5)
b = 3;
else
b = -3;
b = (a > 5 ? 3 : -3);
return 0;
}

int main()
{
int a = 10;
int b = 20;
int max = 0;
if (a > b)
max = a;
else
max = b;
max = (a > b ? a : b);
return 0;
}

逗号表达式

， 优先级别最低，它将两个及其以上的式子联接起来，从左往右逐个计算表达式，整个表达式的值为最后一个表达式的值。

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

1.[  ]下标引用操作符

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

2.（）

调用函数时的（）就是函数调用操作符

3.访问一个结构的成员

 .  操作符，用来访问结构的成员

struct Stu
{
char name[20];
int age;
char id[20];
};
int main()
{
int a = 10;
//使用struct Stu这个类型创建了一个学生对象s1，并初始化
struct Stu s1 = { "张三",20, "202101029"};
printf("%sn", s1.name);
printf("%dn", s1.age);
printf("%sn", s1.id);
return 0;
}

 —>

struct Stu
{
char name[20];
int age;
char id[20];
};
int main()
{
int a = 10;
//使用struct Stu这个类型创建了一个学生对象s1，并初始化
struct Stu s1 = { "张三",20, "202101029"};
struct Stu* ps = &s1;
printf("%sn", ps->name);
printf("%dn", ps->age);
//结构体指针—>成员名
return 0;
}

 表达式求值

隐式类型的转换

C的整型算术运算总是至少已缺省整型类型的精度来进行。为了获得这种精度，表达式中的字符和短整型操作数在使用前辈转换为普通整型，这种转换被称为整型提升。整型算术运算要在计算机cpu内的整型运算器中进行。而整型运算器的操作数字节长度是整形int的字节长度。所以在整型计算时，要将所有数据提升至整形int的字节长度32位，即4字节。但即使是两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整形操作数的标准长度。

int main()
{
char a = 3;
//00000000000000000000000000000011
//00000011 -- a
char b = 127;
//00000000000000000000000001111111
//01111111 -- b
//a和b如何相加
//00000000000000000000000000000011
//00000000000000000000000001111111
//00000000000000000000000010000010
//放到char中，只存八个比特位
//10000010 --c
// 发生整型提升
//11111111111111111111111110000010 -- 补码
//11111111111111111111111110000001 -- 反码
//00000000000000000000000001111110 -- 原码
//-126
char c = a + b;
printf("%dn", c);
return 0;
}

正数的整型提升：

char c1 =  1;

'变量c1的二进制位（补码）中只有八个比特位：00000001

因为char 为有符号的char

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

整型提升后的结果为：

00000000000000000000000000000001

 负数的整型提升：

char c2= -1;

'变量c2的二进制位（补码）中只有八个比特位：11111111

因为char 为有符号的char

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

整型提升后的结果为：

00000000000000000000000011111111

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

算术转换

int main()
{
printf("%un", sizeof(long double));//8
printf("%un", sizeof(double));//8
printf("%un", sizeof(float));//4
printf("%un", sizeof(unsigned long int));//4
printf("%un", sizeof(long int));//4
printf("%un", sizeof(unsigned int));//4
printf("%un", sizeof(int));//4
return 0;
}

 操作符的属性

优先级

第一级：圆括号【（）】、下标运算符【[]】、分量运算符的指向结构体成员运算符【->】、结构体成员运算符【.】。

第二级：逻辑非运算符【!】、按位取反运算符【~】、自增自减运算符【++ --】、负号运算符【-】、类型转换运算符【(类型)】、指针运算符和取地址运算符【*和&】、长度运算符【sizeof】。

第三级：乘法运算符【*】、除法运算符【/】、取余运算符【%】。

第四级：加法运算符【+】、减法运算符【-】。

第五级：左移动运算符【<<】、右移动运算符【>>】。

第六级：关系运算符【< > <= >= 】。

第七级：等于运算符【==】、不等于运算符【!=】。

第八级：按位与运算符【&】。

第九级：按位异或运算符【^】。

第十级：按位或运算符【|】。

第十一级：逻辑与运算符【&&】。

第十二级：逻辑或运算符【||】。

第十三级：条件运算符【?:】。

第十四级：赋值运算符【= += -= *= /= %= >>= <<.= &= |= ^=】。

第十五级：逗号运算符【,】。

最后

以上就是危机犀牛为你收集整理的潜学C语言——操作符的全部内容，希望文章能够帮你解决潜学C语言——操作符所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。