Bootstrap

c语言操作符

   在C语言中,操作符是一种强大的工具,可以用于完成各种计算和逻辑操作。本博客将深入解析C语言中一些常用的操作符技巧,结合实际应用案例和注意事项,帮助读者更好地理解和运用这些操作符,提高代码的效率和可读性。

1.算术操作符:+、-、*、/、%

 在算术运算符中要注意 / (除法)和 % (取模)这两个操作符

  1. 除数不能为0:在进行除法运算时,除数不能为0,否则会导致程序崩溃。如果除数可能为0,应该在程序中添加相应的判断语句,避免除以0的情况发生。

  2. 整数除法的结果取整:在进行整数除法运算时,如果除数和被除数都是整数类型,则结果也是整数类型,并且会向0取整。例如,5 / 2 的结果是2,而不是2.5。如果需要得到精确的小数结果,可以将其中一个操作数转换为浮点数类型。

  3. 取模运算的结果与被除数符号相同:在进行取模运算时,结果的符号与被除数的符号相同。例如,-5 % 3 的结果是-2,而不是1。如果需要得到非负数的结果,可以使用绝对值函数来处理。

  4. 取模运算的结果不是余数:取模运算的结果是除法的余数,但不是余数的绝对值。例如,-5 % 3 的结果是-2,而不是1。如果需要得到余数的绝对值,可以使用余数函数来处理。

示例代码如下 

#include<stdio.h>

int main()
{
	int a = 10, b = 4;
	int sum = a + b;//14
	int diff = a - b;//6
	int product = a * b;//40
	int quotient = a / b;//2
	float quotient_1 = a / b;//2.000000
	float quotient_2 = a /(b * 1.0);//2.500000
	int remainder = a % b;//2
}

2. 关系操作符:<、>、<=、>=、==、!=

 

关系操作符用于比较两个值的大小或者相等关系。常用的关系操作符包括以下几种:

  1. 相等操作符(==):用于判断两个值是否相等。

  2. 不等操作符(!=):用于判断两个值是否不相等。

  3. 大于操作符(>):用于判断一个值是否大于另一个值。

  4. 小于操作符(<):用于判断一个值是否小于另一个值。

  5. 大于等于操作符(>=):用于判断一个值是否大于或等于另一个值。

  6. 小于等于操作符(<=):用于判断一个值是否小于或等于另一个值。

下面是一些关系操作符的代码示例:

#include<stdio.h>

int main()
{
    int a = 10, b = 20;

    if (a == b) {
        printf("a 等于 b\n");
    }
    else {
        printf("a 不等于 b\n");
    }

    if (a != b) {
        printf("a 不等于 b\n");
    }
    else {
        printf("a 等于 b\n");
    }

    if (a > b) {
        printf("a 大于 b\n");
    }
    else {
        printf("a 不大于 b\n");
    }

    if (a < b) {
        printf("a 小于 b\n");
    }
    else {
        printf("a 不小于 b\n");
    }

    if (a >= b) {
        printf("a 大于或等于 b\n");
    }
    else {
        printf("a 小于 b\n");
    }

    if (a <= b) {
        printf("a 小于或等于 b\n");
    }
    else {
        printf("a 大于 b\n");
    }
}

 3.逻辑操作符:&&、||、!

逻辑操作符用于基于逻辑运算的结果来控制程序的流程。常用的逻辑操作符包括以下几种:

  1. 逻辑与操作符(&&):用于判断两个条件是否同时成立。

  2. 逻辑或操作符(||):用于判断两个条件中是否有一个成立。

  3. 逻辑非操作符(!):用于对一个条件进行取反操作。

下面是一些逻辑操作符的代码示例:

#include<stdio.h>

int main()
{
    int a = 10, b = 20, c = 30;

    if (a < b && b < c) {
        printf("a 小于 b且b 小于 c\n");
    }
    else {
        printf("a 不小于 b 或者 b 不小于 c\n");
    }

    if (a > b || b > c) {
        printf("a 大于 b 或者 b 大于 c\n");
    }
    else {
        printf("a 不大于 b 且 b 不大于 c\n");
    }

    if (!(a > b)) {
        printf("a 不大于 b\n");
    }
    else {
        printf("a 大于 b\n");
    }
}

 4.位操作符:&、|、^、~、<<、>>

位操作符是C语言中用于对二进制位进行操作的一种操作符。常用的位操作符包括以下几种:

  1. 按位与(&):对两个操作数的每个二进制位执行按位与操作,并返回结果。例如,a & b 表示对a和b的每个二进制位执行按位与操作。

  2. 按位或(|):对两个操作数的每个二进制位执行按位或操作,并返回结果。例如,a | b 表示对a和b的每个二进制位执行按位或操作。

  3. 按位异或(^):对两个操作数的每个二进制位执行按位异或操作,并返回结果。例如,a ^ b 表示对a和b的每个二进制位执行按位异或操作。

  4. 按位取反(~):对操作数的每个二进制位执行按位取反操作,并返回结果。例如,~a 表示对a的每个二进制位执行按位取反操作。

  5. 左移位(<<):将操作数的二进制位向左移动指定的位数,并返回结果。例如,a << n 表示将a的二进制位向左移动n位。

  6. 右移位(>>):将操作数的二进制位向右移动指定的位数,并返回结果。例如,a >> n 表示将a的二进制位向右移动n位。

下面是一些使用位操作符的代码示例:

#include<stdio.h>

int main()
{
	int a = 0b10110110;
	int b = 0b01101001;

	int c = a & b;  // 按位与,结果为 0b00100000
	int d = a | b;  // 按位或,结果为 0b11111111
	int e = a ^ b;  // 按位异或,结果为 0b11011111
	int f = ~a;     // 按位取反,结果为 0b01001001
	int g = a << 2; // 左移位,结果为 0b11011000
	int h = b >> 3; // 右移位,结果为 0b00001101
}

5.赋值操作符:=、+=、-=、*=、/=、%=

示例代码如下

#include<stdio.h>

int main()
{
	int a = 10; // 将10赋值给变量a,结果为10
	int b = a; // 将变量a的值赋值给变量b,结果为10
	a += 5; // 将变量a的值加上5,并将结果赋值给a,结果为15
	b -= 3; // 将变量b的值减去3,并将结果赋值给b,结果为7
	a *= 2; // 将变量a的值乘以2,并将结果赋值给a,结果为30
	b /= 4; // 将变量b的值除以4,并将结果赋值给b,结果为1
	a %= 3; // 将变量a的值对3取模,并将结果赋值给a,结果为0
}

6.条件操作符:?:

条件操作符(也称为三元操作符)是C语言中的一种特殊的操作符,用于根据条件选择不同的值。条件操作符由问号(?)和冒号(:)组成,语法格式为:条件表达式 ? 结果1 : 结果2,如果条件表达式为真,则返回结果1,否则返回结果2。下面是一些例子:

#include<stdio.h>

int main()
{
	int a = 10, b = 5;
	int max = (a > b) ? a : b; // max的值为10,因为a>b为真
	int min = (a < b) ? a : b; // min的值为5,因为a<b为假
	int abs = (a < 0) ? -a : a; // abs的值为10,因为a<0为假
	int sign = (a < 0) ? -1 : 1; // sign的值为1,因为a<0为假
}

在上面的例子中,第一个条件操作符用于查找a和b中的较大值,第二个条件操作符用于查找a和b中的较小值,第三个条件操作符用于计算a的绝对值,第四个条件操作符用于判断a的符号并返回1或-1。

条件操作符可以使代码更加简洁和优雅,避免了冗长的if语句和重复的代码。需要注意的是,在使用条件操作符时,应该确保结果1和结果2的类型一致,以避免出现类型转换和计算错误。

7.sizeof 操作符

sizeof 操作符是C语言中的一种特殊的操作符,用于计算一个变量或数据类型的大小(字节数)。 sizeof 操作符的语法格式为 sizeof(变量/数据类型)。下面是一些例子:

#include<stdio.h>

int main()
{
    int a;
    size_t size_a = sizeof(a); // 计算整型变量a的大小,4个字节

    short b;
    size_t size_b = sizeof(b); // 计算短整型变量b的大小,2个字节

    long c;
    size_t size_c = sizeof(c); // 计算长整型变量c的大小,8个字节

    long long d;
    size_t size_d = sizeof(d); // 计算长长整型变量d的大小,8个字节

    float e;
    size_t size_e = sizeof(e); // 计算单精度浮点型变量e的大小,4个字节

    double f;
    size_t size_f = sizeof(f); // 计算双精度浮点型变量f的大小,8个字节

    long double g;
    size_t size_g = sizeof(g); // 计算长双精度浮点型变量g的大小,16个字节
    char c = 'A';
    size_t size_c = sizeof(c); // 计算字符型变量c的大小,1个字节
    struct point {
        int x;
        int y;
    };
    size_t size_point = sizeof(struct point); // 计算结构体point的大小,8个字节(假设int类型为4个字节)
}

8.自增,自减操作符:++,--

自增操作符 ++ 和自减操作符 -- 用于对变量进行递增和递减。自增操作符 ++ 可以使一个变量的值加1,自减操作符 -- 可以使一个变量的值减1。这两个操作符可以作为前缀或后缀使用,分别表示先进行自增/自减操作还是先使用变量的值。下面是一些例子:

#include<stdio.h>

int main()
{
    int a = 5;
    int b = ++a; // a的值变为6,b的值也为6,因为先进行自增操作再赋值
    int c = a--; // a的值变为5,c的值为6,因为先使用a的值再进行自减操作
    int d = a++; // a的值变为6,d的值为5,因为先使用a的值再进行自增操作
}

在上面的例子中,第一个自增操作符用于将变量 a 的值加1并赋值给变量 b,第二个自减操作符用于将变量 a 的值减1并赋值给变量 c,第三个自增操作符用于将变量 a 的值加1并赋值给变量 d。

但需要注意的是,自增/自减操作符有一定的优先级,应该注意使用括号来明确优先级。此外,自增/自减操作符也可以应用于指针变量,表示指针值的增加或减少。

9.指针操作符:&、* 

 指针操作符是C语言中的一种基本操作符,用于处理指针类型数据。在C语言中,指针操作符包括取地址操作符(&)和解引用操作符(*)。下面是一些指针操作符的代码示例:

  1. 取地址操作符(&):

    int a = 10;
    int *ptr = &a; // 取a的地址,并将其赋值给ptr
  2. 解引用操作符(*):

    int a = 10;
    int *ptr = &a; // 取a的地址,并将其赋值给ptr
    *ptr = 20; // 解引用ptr,将20赋值给a
  3. 指针运算符(+、-、++、--):

    int a[5] = {1, 2, 3, 4, 5};
    int *ptr = a; // 将a的地址赋值给ptr,相当于ptr = &a[0];
    ptr++; // 指针后移一位,指向a[1]
    (*ptr)++; // 解引用ptr,将a[1]的值加1
  4. 指针与数组的关系:

    int a[5] = {1, 2, 3, 4, 5};
    int *ptr = a; // 将a的地址赋值给ptr,相当于ptr = &a[0];
    int sum = 0;
    for (int i = 0; i < 5; i++)
    {
        sum += *(ptr + i); // 相当于sum += a[i];
    }
  5. 指针与函数的关系:

    void swap(int *a, int *b)
    {
        int temp = *a;
        *a = *b;
        *b = temp;
    }
    int main()
    {
        int a = 10, b = 20;
        swap(&a, &b); // 将a和b的地址传递给swap函数,实现交换
        return 0;
    }

 10.逗号表达式

逗号表达式可以用来分隔多个表达式,并按照顺序依次计算这些表达式,最终返回最后一个表达式的值。逗号运算符的基本语法如下:

expr1, expr2, expr3, ..., exprn

其中,expr1到exprn为多个表达式,逗号用于分隔这些表达式。在计算这些表达式时,逗号的优先级是最低的,因此会按照从左到右的顺序依次计算这些表达式,并返回最后一个表达式的值。例如: 

int a = 10, b = 20, c = 30;
int max = (a > b, a > c) ? a : ((b > c) ? b : c); // 使用逗号运算符计算a>b和a>c,并返回最大值

在上面的例子中,逗号运算符用于计算a>b和a>c,返回结果为false和true,但是最终返回的是最后一个表达式的值true,因为逗号运算符的优先级最低。 

11.复合赋值运算符:+=、-=、*=、/=、%=、<<=、>>=、&=、^=、|=

复合赋值运算符是C语言中的一种运算符,用于将运算结果赋值给左侧的操作数。C语言提供了多种不同的复合赋值运算符,包括+=、-=、*=、/=、%=、<<=、>>=、&=、^=和|=等。下面是一些复合赋值运算符的代码示例:

  1. 加等于(+=):

    int a = 10;
    a += 5; // 相当于 a = a + 5;
    
  2. 减等于(-=):

    int a = 10;
    a -= 5; // 相当于 a = a - 5;
    
  3. 乘等于(*=):

    int a = 10;
    a *= 2; // 相当于 a = a * 2;
  4. 除等于(/=):

    int a = 10;
    a /= 2; // 相当于 a = a / 2;
    
  5. 取模等于(%=):

    int a = 10;
    a %= 3; // 相当于 a = a % 3;
  6. 左移等于(<<=):

    int a = 10;
    a <<= 2; // 相当于 a = a << 2;
  7. 右移等于(>>=):

    int a = 10;
    a >>= 2; // 相当于 a = a >> 2;
  8. 与等于(&=):

    int a = 10;
    a &= 6; // 相当于 a = a & 6;
  9. 异或等于(^=):

    int a = 10;
    a ^= 6; // 相当于 a = a ^ 6;
  10. 或等于(|=):

    int a = 10;
    a |= 6; // 相当于 a = a | 6;
;