认识C语言前期所有操作符

1位操作符

#include<stdio.h>

// & - 按（二进制）位与

// | - 按（二进制）位或

// ^ - 按（二进制）位异或

int main()

{

int a = 3;

int b = -5;

//00000000000000000000000000000011 - a的补码（正数的补码，反码，原码不变）

//

//10000000000000000000000000000101 - b

//11111111111111111111111111111010 - b反码+1是补码

//11111111111111111111111111111011 - b补码

//

// a & b

//11111111111111111111111111111011 - b补码

//00000000000000000000000000000011 - a的补码（正数的补码，反码，原码不变）

// 按位与上下两个数字同时为1才为1，只要有0就是0

//00000000000000000000000000000011 - c补码

int c = a & b;

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

int d = 3;

int e = -5;

//00000000000000000000000000000011 - d的补码（正数的补码，反码，原码不变）

//

//10000000000000000000000000000101 - e

//11111111111111111111111111111010 - e反码+1是补码

//11111111111111111111111111111011 - e补码

//

//f = d | e

//00000000000000000000000000000011

//11111111111111111111111111111011

//按位或上下两个数字同时为0才为0，只要有1就是1

//11111111111111111111111111111011 - f补码-1

//11111111111111111111111111111010 - f反码

//10000000000000000000000000000101 - f原码 为 -5

int f = d | e;

printf("f=%d\n",f);

int i = 3;

int j = -5;

//00000000000000000000000000000011 - i的补码（正数的补码，反码，原码不变）

//

//10000000000000000000000000000101 - j

//11111111111111111111111111111010 - j反码+1是补码

//11111111111111111111111111111011 - j的补码

//

// h = i^j

//00000000000000000000000000000011 - i的补码

//11111111111111111111111111111011 - j的补码

//按位异或是相同为0，相异为1

//11111111111111111111111111111000 - h的补码-1

//11111111111111111111111111110111 - h的反码

//10000000000000000000000000001000 - h的原码 为 -8

//int h = i ^ j;

//printf("h=%d\n", h);

//加法容易溢出，不易计算

printf("\n");

//int g = 2;

//int k = 1;

//printf("交换前 : g = %d , k = %d\n", g, k);

//g = g + k;

//k = g - k;

//g = g - k;

//printf("交换后 : g = %d , k = %d\n", g, k);

交换不容易溢出，但是效率低，（面试题）不创建第其他变量的情况下进行两数交换

int g = 2;

int k = 1;

printf("交换前 : g = %d , k = %d\n", g, k);

g = g ^ k; //(2^1)

k = g ^ k; //(2^1)^1 = 2

g = g ^ k; //(2^1)^2 = 1

printf("交换后 : g = %d , k = %d\n", g, k);

一般都是创建变量去交换两数，效率高，用时少

int g = 2;

int k = 1;

int c = 0;

printf("交换前 : g = %d , k = %d\n", g, k);

c = g;

g = k;

g = c;

printf("交换后 : g = %d , k = %d\n", g, k);

编写代码实现：求一个整数存储在内存中二进制中1的个数

求补码二进制中1的个数

printf("\n");

int x = -7;

int y = 0;

int count = 0;

for (y = 0; y < 32; y++)

{

if ((x & 1) == 1 )

{

count = count + 1;

}

x = x >> 1;

}

printf("%d", count);

return 0;

}

//-7

// 10000000000000000000000000000111 原码

// 11111111111111111111111111111000 反码

// 11111111111111111111111111111001 补码

2.单目操作符

#include<stdio.h>

#include<stdlib.h>

//单目操作符 - 只有一个可以操作的数

//双目操作符 - 有两个可以操作的数

int main()

{

int a = 1;

! 单目操作符非，把真的变成假的，假的变成真的

//if (!a) //如果是假的话，进入分支

//{ }

//if(a) //如果是真的话，进入分支

//{ }

 + - 单目操作符正负，可以给单个的数赋值正负

int i = -2; //i = -2

int j = -i; //j = 2

printf("i = %d\n", i);

printf("j = %d\n", j);

printf("\n");

& 单目操作符取地址，可以取一个变量的地址

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

int* p = &a;

printf("%p\n", p);//两种写法效果都一样

printf("\n");

sizeof 单目操作符计算类型所创变量的空间大小/变量的大小，单位字节

int b = 1;

printf("%zu\n", sizeof(b)); //变量

printf("%zu\n", sizeof(int)); //类型

printf("\n");

 ~ 按位取反

int c = 3;

00000000000000000000000000000011 补码

11111111111111111111111111111100 ~c补码

11111111111111111111111111111011 反码

10000000000000000000000000000100 原码

 -4

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

c |= (1 << 2);

00000000000000000000000000000011 补码

或等（把第三位变成1，就是<<符号后n-1位）

00000000000000000000000000000100 (1<<2)

// |=后

//00000000000000000000000000000111

//结果变成了7

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

//想让第三个数字变成0

c &= (~(1 << 2));

//00000000000000000000000000000111 - c现在的数字

//00000000000000000000000000000100 - 1<<2

//11111111111111111111111111111011 - (~(1<<2))

//00000000000000000000000000000111 - c现在的数字

//00000000000000000000000000000011 - 又回到了原来的数字

//

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

//也可以把除第一位以外的数字变成0

c &= 3;

//00000000000000000000000000000111

//00000000000000000000000000000011

//两个都是1才取1，否则都是0

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

printf("\n");

++ --单目操作符自增自减

printf("前置++，后置++\n");

int d = 1;              //2

int e = ++d;          //2

//d = d + 1 ; e = d;

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

printf("e=%d\n", e);

int f = 1;               //2

int g = f++;            //1

//g = f ; f = f + 1 ;

printf("f=%d\n", f);

printf("g=%d\n", g);

printf("\n");

printf("前置--，后置--\n");

int h = 2;                   //1

int k = h--;                 //2

// k = h ; h = h - 1;

printf("h=%d\n", h);

printf("k=%d\n", k);

int m = 2;                //1

int n = --m;              //1

//m = m - 1 ; n = m ;

printf("m=%d\n", m);

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

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

printf("\n");

int o = 10;

int* q = &o;

*q = 20;

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

(类型)强制类型转换

srand((unsigned int)time(NULL));

//time前面就是强制类型转换从time_t是long long类型转换为unsigned int 类型

//int t = 3.14;

int t = (int)3.14;

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

sizeof题

printf("\n");

int r = 10;

printf("%zd\n", sizeof(r));

printf("%zd\n", sizeof(int));

printf("%zd\n", sizeof r );

//printf("%d", sizeof int ); err错误的写法

//

//表明sizeof是操作符不是函数

//如果是函数就不能去括号

//但是strlen是库函数，求的是字符串的长度

return 0;

}

3.逻辑关系符

#include<stdio.h>

int main()

{

//逻辑操作符

&& 如果第一个表达式为假，就不继续算后面的表达式

|| 如果第一个表达式为真，就不继续算后面的表达式

int i = 0;

int a = 1, b = 2, c = 3, d = 4;

    2            3          4            5                                       //最后结果

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

    1             2         4            4                                       //i的内容结果

//      2        2       3       4

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

//      1        2        3       4

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

printf("\n");

int e = 0, f = 1, g = 2;

    1            2          3 //最后结果

//i = ++e && f++ && g++;

     1           1           2 //i的内容结果

     1            1         2 //最后结果

//i = e++ && f++ && g++;

      0           1          2 //i的内容结果

//     1        2       2 //最后结果

i = e++ || f++ || g++;

//     0        1        2 //i的内容结果

printf("e = %d\nf = %d\ng = %d\n", e,f,g);

}

4.条件操作符又可以称为三目操作符

其表达式为: (exp1 ? exp2 :exp3)

#include<stdio.h>

int main()

{

//深度解刨三目操作符

int i = 0;

int a = 1, b = 2;

i = (a < b ? a : b);

如果第一个表达式如果为真，就执行第二个表达式

如果第一个表达式如果为假，就执行第三个表达式

//用if语句解释就是这个道理：

if (a < b)

{

 i = a;

}

else

{

 i = b;

}

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

return 0;

}

5.下标操作符，函数操作符，结构成员操作符

#define _CRT_SECURE_NO_WARNINGS

#include<stdio.h>

//int main()

//{

 [ ] 操作符是下标操作符

//

 int arr1[10] = { 0 };

arr1[2] = 3;

下标应用操作符[]是可以引用名称

但是不能便利，定义一个单独的值是可以使用的

3[arr1] = 4;

printf("%d\n", 2[arr1]);

/printf("%d\n", 3[arr1]);

 return 0;

}

（）操作符是函数操作符

int Add(int a, int b)

{

 return a + b;

}

int main()

{

 int a = 10;

 int b = 20;

 int c = Add(a, b);

()不能去掉，（）是函数操作符

sizeof（）后面的括号是可以去掉的，因为sizeof是单独的操作符而不是函数

这个函数有三个操作数Add，a，b

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

 return 0;

}

#include<string.h>

结构成员操作符分为两种：

. 操作符

 -> 操作符

struct stu

{

char name[10];

int age;

double score;

};

void set_stu(struct stu* ps)

{

. 操作符是结构体成员加 . 加参数

strcpy((*ps).name, "zhangsan");

(*ps).age = 20;

(*ps).score = 100.0;

}

void print_stu(struct stu* ps)

{

-> 操作符是结构体指针加 -> 加参数

他们两个都是等价的

printf("%s %d %lf\n", ps->name, ps->age, ps->score);

}

int main()

{

struct stu s = { 0 };

set_stu(&s);

print_stu(&s);

return 0;

}

结构体的结果：