C语言入门之操作符与表达式

前言

本篇文章主要包括各种操作符的介绍与表达式求值，欢迎各位小伙伴与我一起学习。

一、操作符

1.算术操作符



   +  加    -  减    *  乘    /  除    %  取余

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = 5/2;

    printf("%d",a);

    return 0;

}

#include <stdio.h>

#include <stdlib.h>

int main()

{

    float a = 5.0/2;

    printf("%lf",a);

    return 0;

}

除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
对于 / 操作符，如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
%操作符的两个操作数必须为整数，返回的是整除之后的余数。

2.移位操作符

<<  左移操作符

>>  右移操作符

左移操作符规则

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = 5;

    int b = a<<1;

    printf("%d",b);

    return 0;

}

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

警告：对于位运算符，不要移动负数位，这个是标准未定义的。

例：

int num=10;

num>> -1 ;

右移操作符规则

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = 16;

    // >> 右移操作符

    //移动的是二进制位

    //00000000000000000000000000010000

    //32个bit位

    int b = a>>1;

    printf("%d",b);

    return 0;

}

右移操作符：

1.算术右移：

右边丢弃，左边补原符号位（我们见到的基本上都是算术右移）

2.逻辑右移：

右边丢弃，左边补0

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = -1;

    //存储到内存的是补码

    //1000000000000000000000000000001

    //第一位是符号位，1表示负数，0表示正数

    int b = a>>1;

    printf("%d",b);

    return 0;

}

整数的二进制表示形式有三种（正数的反码和补码与原码一样）

原码：直接根据数值写出的二进制序列

反码：原码的符号位不变，其他位按位取反就是反码

补码：反码+1

例：

-1的原反补：

原码：1000000 00000000 00000000 00000001

反码：1111111 11111111 11111111 11111110

补码：1111111 11111111 11111111 11111111

3.位操作符

按位与操作符：&

按位或操作符： |

按位异或操作符： ^

都是用补码进行计算，如果是负数，要先找出它的补码进行计算：a-b=a的补码+(-b)的补码

按位与：有一个为0，结果就为0，两个都为1，结果才为1.

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = 3;

    int b = 5;

    int c = a&b;

    printf("%d",c);

    return 0;

}

按位或：有一个为1，结果就为1，两个都为0，结果才为0.

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = 3;

    int b = 5;

    int c = a|b;

    printf("%d",c);

    return 0;

}

按位异或：相同为0，相异为1.

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = 3;

    int b = 5;

    int c = a^b;

    printf("%d",c);

    return 0;

}

不创建临时变量（第三个变量），交换两个数：

1.加减法

缺点：可能会溢出，不可取

a = a + b;

b = a - b;

a = a - b;

2.乘除法

缺点：可能会溢出，不可取

a = a * b;

b = a / b;

a = a / b;

3.异或法

不会溢出

a = a ^ b;

b = a ^ b;

a = a ^ b;

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = 2;

    int b = 5;

    a = a ^ b;

    b = a ^ b;

    a = a ^ b;

    printf("a: %d \n", a);

    printf("b: %d \n", b);

    return 0;

}

//第一次：010^101=111

//第二次：111^101=010

//第三次：111^010=101

4.赋值操作符

赋值操作符就是你的变量已经有一个值了，但是你不满意，你就可以使用它把一个新的值赋值给它，其实就是把右边的值赋值到左边，放进变量里进行存储。

赋值操作符是一个等号，而判断操作符是两个等号。

复合操作符:

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

5.单目运算符



   !	                     逻辑反操作

   -	                     负值

   +	                     正值

   &	                     取地址

   sizeof	                 操作数的类型长度

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

   --	                     前置，后置--

   ++	                     前置，后置++

   *	                     间接访问操作符

  (类型)                      强制转换类型

取地址:

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = 5;

    int* p = &a;

    *p = 10;

    printf("%p\n", &a);

    printf("*pa: %d\n", *pa);

    printf("a: %d\n", a);

    return 0;

}

sizeof 计算的是变量所占内存空间的大小:

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = 10;

    char c = 'r';

    char* p = &c;

    int arr[10] = { 0 };

    printf("%d\n",sizeof(a));

    printf("%d\n",sizeof(c));

    printf("%d\n",sizeof(p));

    printf("%d\n",sizeof(arr));

    return 0;

}

#include <stdio.h>

#include <stdlib.h>

int main()

{

    short s = 0;

    int a = 10;

    printf("%d\n",sizeof(s = a + 5));

    //算的是s的大小，s是short型，占两个字节

    //sizeof里的表达式不进行运算

    printf("%d\n",s);

    return 0;

}

++ 的使用：

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = 10;

    int b = 10;

    printf("%d\n",++a);

    printf("%d\n",b++);

    printf("%d\n",b);

    return 0;

}

强制类型转换：

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = (float)3.14;

    //将float类型强制转换成int类型

    printf("%d\n",a);

    return 0;

}

sizeof与数组：

#include <stdio.h>

#include <stdlib.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);

    test1(ch);

    return 0;

}

6.关系操作符



 > , >=

 < , <=

 !=                   不等于

 ==                   判断两个数是否相等

 =                    赋值

7.逻辑操作符

      逻辑与       &&

      逻辑或       ||

&&：如果逻辑与左边的条件为假的话，后面就不用算了

#include <stdio.h>

#include <stdlib.h>

int main()

{

	int a = 0;

	int b = 2;

	int c = 3;

	int d = 4;

	int i = 0;

	i = a++ && ++b && d++;

	printf(" a = %d\n b = %d\n c = %d\n d = %d\n", a, b, c,d);

	return 0;

}

||：如果逻辑或左边的条件为真的话，后面就不用算了

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = 0;

    int b = 2;

    int c = 3;

    int d = 4;

    int i = 0;

    i = a++ || ++b || d++;

    printf(" a = %d\n b = %d\n c = %d\n d = %d\n", a, b, c,d);

    return 0;

}

8.条件运算符

exp1 ? exp2 : exp3

三目操作符： x > n ? 1 : 0

这里的意思是x大于n吗？true返回1，否则为0

9.逗号运算符

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

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int a = 1;

    int b = 2;

    int c = (a > b,a = b + 1,a,b = a + 1);

    printf("%d\n",c);

}

10.下标访问，函数调用和结构成员



   1. [ ]下标引用操作符，操作数：一个数组名 + 一个索引值

   2. 函数调用操作符( )，一个函数callFunc( )

   3. 结构成员访问操作符分两种 . 和 ->

1.下标访问：

#include <stdio.h>

#include <stdlib.h>

int main()

{

    int arr[10] = {1,2,3,4,5,6,7,8,9,10};

    printf("%d\n",arr[9]);

    return 0；

}

2.函数调用：

#include <stdio.h>

#include <stdlib.h>

int get_max(int x,int y)

{

    if(x > y)

        return x;

    else

        return y;

}

int main()

{

    int a,b;

    int max = 0;

    scanf_s("%d%d",&a,&b);

    max = get_max(a,b);

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

    //操作数有三个，函数名get_max，参数a和b

    printf("%d\n",max);

    return 0;

}

3.访问一个结构体的成员：

#include <stdio.h>

#include <stdlib.h>

  struct str

{

    char name[20];

    char id[20];

    int age;

};

int main()

{

    struct str s = {"uzi", "006", 18};

    printf("Name: %s\n", s.name);

    printf("Id : %s\n", s.id);

    printf("Age: %d\n", s.age);

	return 0;

}

它本身就向内存申请了一部分空间，你也可以用指针来写

#include <stdio.h>

#include <stdlib.h>

  struct str

{

    char name[20];

    char id[20];

    int age;

};

int main()

{

    struct str s = {"uzi", "006", 18};

    struct str* ps = &s;

    printf("%s\n", (*ps).name);

  //也可以这样写：printf("%s\n", ps->name);

	return 0;

}

二、表达式求值

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

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

隐式类型转换

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

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

如何进行整体提升？

整型提升是按照数据类型的符号位来提升的。

整形提升规则：有符号数,高位补符号位 ; 无符号数,高位补0.

#include <stdio.h>

#include <stdlib.h>

int main()

{

    char a = 3;

    //000000000000000000000011

    //它取值时取的是它的高位：00000011  -a

    char b = 127;

    //000000000000000001111111

    //高位：01111111  -b

    char c = a + b;

    //000000000000000000000011  -a

    //000000000000000001111111  -b

    //000000000000000010000010  -c

    //a和b在这之前已经发生整型提升

    printf("%d\n",c)

    //高位：10000010  -c

    //111111111111111110000010 -补码

    //111111111111111110000001 -反码

    //100000000000000001111110 -原码

    //-126

    return 0;

}

算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。

下面的层次体系成为：寻常算术转化。

   long double

   double

   float

   unsugned long int

   long int

   unsigned int

   int

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

注意：算数转换要合理，要不然会有一些潜在的问题

操作符的属性

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

1.操作符的优先级

2.操作符的结合性

3.是否控制求值顺序

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

#include <stdio.h>

#include <stdlib.h>

  int fun()

{

    static int count = 1;

    return ++count;

    //2   3   4

}

int main()

{

    int anwer;

    anwer = fun() - fun()*fun();

    printf("%d\n", anwer);

//这个代码是有问题的，你不知道它先调用的是谁

//有可能是2-3*4  又或者是4-2*3

	return 0;

}

注意：一定要保证只有唯一的一个运算顺序，不然代码就是错误的。

结尾

为梦想颠簸的人有很多，不差你一个，但如果你能坚持到最后，那你就是唯一。半山腰太挤了，总得去山顶看看。

巴特西

C语言-操作符与表达式