C语言操作符简介

最新推荐文章于 2024-11-02 20:23:59 发布

IRON@MAN

最新推荐文章于 2024-11-02 20:23:59 发布

阅读量121

点赞数

文章标签： c语言 html5 javascript

本文链接：https://blog.csdn.net/CQR1230/article/details/120613339

版权

算术操作符：
+加 -减 *乘 /除 %取模（也就是取余数，例1）

移位操作符：(分为左移和右移，例2)
<<左移操作符 >>右移操作符

位操作符:(例3)
& ^ |

赋值操作符：(例4)
= += -= *= /= &= ^= |= >>= <<= ==

单目操作符：（例5）
!逻辑反操作 -负值 +正值 &取地址 sizeof操作数的类型长度(以字节为单位) ~对一个数的二进制按位取反 --前置、后置-- ++前置、后置++ *间接访问操作符(解引用操作符) (类型)强制类型转换

关系操作符：
< <= > >= != ==

逻辑操作符:（例6）
&&逻辑与 ||逻辑或

条件操作符：(例7)
exp1 ? exp2 : exp3 （表达式1的结果为真，那么表达式2执行，表达式2的结果就是整个表达式的结果。如果表达式1的结果为假，那么表达式3执行，表达式3的结果就是整个表达式的结果）

下标引用、函数调用和结构成员：（例8）
[] () . ->

常见关键字：(例9) [关键字不能与自定义的呃变量冲突]
auto break case char const continue default do double else enum extern float goto if int long regeister(定义寄存器变量；在定义一个变量时在int前加上regeister就可以将变量放到寄存器内提升运行速度)
return shot signed sizeof static struct switch typedef union unsigned void volatile while

#define定义常量和宏（例10）

指针：（例11）

结构体：(例12)
结构体是C语言中特别重要的知识点，结构体使得C语言有能力描述复杂类型。
比如描述学生，学生包含：名字+年龄+性别+学号这几项信息。
这里只能使用结构体来描述

/*例1*/
//#include<stdio.h>
//int main()
//{
//   int a = 5/2;//5除以2，商2余1，"/"代表的是商，所以打印结果是2
//   printf("%d\n", a);
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   int a = 5%2;//5除以2，商2余1，"%"代表的是取模，所以打印结果是1
//   printf("%d\n", a);
//   return 0;
//}

/*例2*/
//#include<stdio.h>
//int main()
//{
//   //移位操作符其实是移的是二进制位
//   int a = 1;
//   //一个整形占4个字节--32个比特位
//   //那么赋值给a的其实是‘0000000000000000000001’
// int b = a << 1; //用b接收a移动后的值
//   //a向左移动一位。就是将二进制中的所有数字向左移动1位后面补一个0。变为‘0000000000000000000010’
//   printf("%d\n", b);//打印后的结果为2
//   printf("%d\n", a);//a的值不变还是1
//   return 0;
//}

/*例3*/
//#include<stdio.h>
//int main()
//{
//   //位操作符。这里的位仍然代表的是2进制位
//   //&--按位与
//   //|--按位或
//   //^--按位异或
//   int a = 3;
//   int b = 5;
//   int c = a&b;
//   //将a转换到二进制位是011
//   //将b转化为二进制位是101
//   //“按位与”中"与"的意思其实就是并集
//   //0 1 1
//   //1 0 1
//   //在第一列有0和1,0为假1为真，那么并集就为假，两者取并集的结果就是0。以此类推，第二列的结果也为0，第三列的结果1和1都为真，则取并集后结果为1。
//   //那么a&b的结果就是001
//   printf("%d\n", c); //打印出来的结果是1
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   int a = 3;
//   int b = 5;
//   int c = a|b;
//   //将a转换到二进制位是011
//   //将b转化为二进制位是101
//   //“按位或”的意思就是一列数之间只要有一个为真那么就为真
//   //0 1 1
//   //1 0 1
//   //在第一列有0和1,0为假1为真,那么“按位或”计算过后的结果就是1
//   //a|b的结果就是111
// printf("%d\n", c);//打印出来的结果是7
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   int a = 3;
//   int b = 5;
//   int c = a^b; //'^'的意思是异或
//   //异或的意思：对应的二进制位相同，则为0；对应的二进制位相异，则为1.
//   //0 1 1
//   //1 0 1
//   //第一列0和1相异那么值为1，第二例1和0相异那么值为1，第三列1和1相同那么值为0
//   //"a^b"的结果就是110
//   printf("%d\n", c); //打印出来的结果就是6
//   return 0;
//}

/*例4*/
//#include<stdio.h>
//int main()
//{
//   int a = 10; //'='-->赋值 '=='-->判断相等
//   int a += 10; //这行代码的意思是"int a = a + 10"
//   int a -= 20;//这行代码的意思是"int a = a - 20"
//   int a &= 2; //这行代码的意思是"int a = a&2"
//   return 0;
//}

/*例5*/
//#include<stdio.h>
//int main()
//{
// /*int a = 10;
//   int b = 20;
//   a+b//这里的+就是双目操作符。因为+左边和右边都有操作数，那么+有两个操作数为双目操作符*/
//   int a = 10;
//   printf("%d\n", a); //!的作用是把真变成假，把假变成真
//   //在C语言中0代表假，其余一切非0数字代表真
//   printf("%d\n", !a); //！将a逻辑反操作，本来a=10为真，加上！后a就变为假值为0
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   int a = -2;//对2进行取负
//   int b = -a;//对a进行取负
//   int c = +3;//+正号通常都会省略
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   int a = 10;
//   //sizeof计算的是变量或者类型所占空间的大小，单位是字节
//   printf("%d\n", sizeof(a));//变量a为整形，占四个字节的大小
//   printf("%d\n", sizeof(long long));
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   int arr[10] = {0}; //十个整形元素的数组
//   int sz = 0;
//   //10*sizeof (int) = 40
//   printf("%d\n", sizeof(arr));
//   //计算数组元素的个数
//   //数组总大小除以每个元素的大小
//   sz = sizeof(arr)/sizeof(arr[0]);//sizeof(arr[0])第一个元素的大小，sizeof(arr)总元素的大小
//   printf("sz = %d\n", sz);
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   int a = 0;//4个字节，32个比特位
//   int b = ~a;//b是有符号的整形
//   // ~ 按位取反（这里的位依然代表二进制位），例如：一个二进制数1010在取反之后变为0101
//   //00000000000000000000000000000000
//   //11111111111111111111111111111111 //在这里如果第一个数字为1则代表的是负号，如果第一个数字为0则代表的是正号。最高位为符号位
//   //负数在内存中存的是补码
//   printf("%d\n", b);//我们使用的、打印的是这个数的原码
//   //计算过程：原码最高位不变其余位取反得到反码，反码加1得到补码
//   //11111111111111111111111111111111(补码)
//   //11111111111111111111111111111110（反码）
//   //10000000000000000000000000000001(原码)最高位是1代表负数
//   //所以打印出来的是-1
//   return 0;
//}

// 只要是整数，内存中存的都是二进制的补码
//正数-->原码、反码、补码相同
//负数-->存的是补码
/*
-2的原码是10000000000000000000000000000010
反码是11111111111111111111111111111101
补码是11111111111111111111111111111110
*/

//#include<stdio.h>
//int main()
//{
//   int a = 10;
//   int b = a++;//后置++。意思就是先把a的值赋给b，然后再让a+1
//   printf("a = %d b = %d", a, b); //所以打印出来的是a = 11，b = 10.
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   int a = 10;
//   int b = ++a;//前置++。意思就是先让a+1，然后再赋值给b
//   printf("a = %d b = %d", a, b); //所以打印出来的是a = 11，b = 11.
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   int a = 10;
//   int b = a--;//后置--。意思就是先把a的值赋给b，然后再让a+1
//   printf("a = %d b = %d", a, b); //所以打印出来的是a = 9，b = 10.
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   int a = 10;
//   int b = --a;//前置--。意思就是先让a-1，然后再把a的值赋给b
//   printf("a = %d b = %d", a, b); //所以打印出来的是a = 9，b = 9.
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   //(类型) 强制类型转换
//   int a = (int)3.14;//将3.14这个double类型的数据强制转换为int类型
//   printf("%d\n", a);
//   return 0;
//}

/*例6*/
//#include<stdio.h>
//int main()
//{
//   //C语言中0表示假，一切的非0数值表示真
//   int a = 3;
//   int b = 5;
//   int c = a && b; //a为真，并且b也为真，那么&&为真,所以说c也为真，c打印出来的结果默认为1
//   printf("c = %d\n", c);
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   //C语言中0表示假，一切的非0数值表示真
//   int a = 0;
//   int b = 5;
//   int c = a && b; //a为假，并且b也为真，那么&&为假,所以说c也为假，c打印出来的结果就为0
//   printf("c = %d\n", c);
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   //'||'为逻辑或，只要有一个为真那么就为真
//   int a = 0;
//   int b = 5;
//   int c = a || b;
//   printf("c = %d\n", c);
//   return 0;
//}

/*例7*/
//#include<stdio.h>
//int main()
//{
//   int a = 10;
//   int b = 20;
//   int max = 0;
//   max = (a>b ? a : b);
   if(a>b)
max = a;
else
max = b;
printf("")
// printf("max = %d\n", max);
//   return 0;
//}

/*例8*/
//#include<stdio.h>
//int Add(int x, int y)
//{
//   int z = 0;
//   z = x + y;
//   return z;
//}
//int main()
//{
//   /*int arr[] = { 0 };
//   arr[4];//访问arr下标为4的元素 []--下标引用操作符 */
//   int a = 10;
//   int b = 20;
// int sum = Add(a, b);//这里的"()"为函数调用操作符
//   return 0;
//}

/*例9*/
//#include<stdio.h>
//int main()
//{
// auto int a = 10;//局部变量。因为a这个变量在大括号开始时自动生效，在大括号结束时自动销毁，多也叫做自动变量。前面的auto一般省略
// return 0;
//}

//#include<stdio.h>
//int main()
//{
//   //int-->定义有符号变量
//   unsigned int num = -1; //unsigned-->定义无符号变量，也就是永远都是正值。即使赋给num的是一个负值，系统也默认它为正值
// printf("%d\n", num);
//   return 0;
//}

//#include<stido.h>
//int main()
//{
//   //struct --> 结构体关键字
//   //typedef --> 类型定义
//   //union --> 联合体/共用体
//   //void --> 无/空
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   //typedef -->类型定义 -->类型重定义
//   typedef unsigned int u_int;//将"unsinged int"重新定义为"u_int",这样在使用的时候比较容易
//   u_int num = -2;
//   printf("%d\n", num);
//   return 0;
//}

//#include<stdio.h>
1. static-->修饰局部变量
局部变量的生命周期变长
//void test()
//{
//   static int a = 0;// a 是一个静态的局部变量
//   //加上static之后会把a++后的结果给累积下,保存上一次留下的值. 否则a每次输入的时候都是0，a++后的结果都是1
//   a++;
//   printf("a = %d\n", a);
//}
//int main()
//{
//   int i = 0;
//   while(i < 5)
//   {
//       test(i);
//       i++;
//   }
//   return 0;
//}

#include<stdio.h>
int sum(int a)
{
   int c = 0;
   static int b = 3; //将b每次计算过后的值都保存下来用于下一次循环的计算
   c += 1; // c += 1;等价于 c =c + 1
   b += 2;
   return (a + b + c); // 将a + b + c的值传给d
}
int main()
{
   int d = 2;
   int i;
   for(i = 0; i < 5; i++)
   {
       printf("%d\n", sum(d));
   }
   return 0;
}

//#include<stdio.h>
2. static-->修饰全局变量
缩小了全局变量的作用域 -- 让静态的全局变量只能在自己所在的源文件内部使用，而在一个项目的其他源文件内部无法使用
//static int g_val = 2020;
//int main()
//{
// printf("g_val = %d\n", g_val);
// return 0;
//}

//#include<stdio.h>
3. static-->修饰全局变量
改变了函数的链接属性
一个正常函数的链接属性是外部连接
前面加上static之后属性就改为了内部链接，也就是说只能在一个他所在的源文件内部使用，不能在同一项目的其他源文件使用。
//int Add(int x, int y)
//{
//   int z = 0;
//   z = x + y;
//   return z;
//}
//int main()
//{
//   int a = 10;
//   int b = 20;
//   int sum = Add(a, b);
//   printf("sum = %d\n", sum);
//   return 0;
//}

/*例10*/
//#include<stdio.h>
//#define MAX 100// #define 定义标识符常量
//int main()
//{
//   int a = MAX;
//   printf("%d\n", a);
//   return 0;
//}

//#include<stdio.h>
#define可以定义宏。宏-->在标识符常量上加上了参数
//#define MIN(x, y) (x > y? y: x)// 前面定义的宏会被替换为后面设置的函数。也就是“MAX(x, y)”被替换为“(x > y? x: y)”
// //这里复习一下三目操作符
//                           // "?"之前的判断如果成立的话输出结果为 x，如果不成立输出结果为 y
//int main()
//{
//   int a = 10;
//   int b =20;
//   int min = MIN(a, b);
//   // max = (a>b?a:b)
//   printf("min = %d\n", min);
//   return 0;
//}

//define 定义标识符常量
//#define MAX 1000
//define 定义宏
//#include<stdio.h>
//#define ADD(x ,y) ((x) + (y))
//int main()
//{
//   int sum = ADD(2, 3);
//   printf("sum = %d\n", sum);
//   sum = 10*ADD(2,3);
//   printf("sum = %d\n", sum);
//   return 0;
//}

/*例11*/
//#include<stdio.h>
//int main()
//{
//   int a = 10;//在内存中申请4个字节的空间
//   int* p = &a; //"&"取地址符号。这句话的意思就是取出a的地址
//   //有一种变量是用来存放地址的，这种变量就称为指针变量。用 int* 来赋值
//   printf("%p\n", &a);//打印出的结果就是a在计算机内存中的地址
//   printf("%d\n", p);
//   //*p;//* --> 解引用操作符。意思就是对p进行解引用操作，找到它所指的对象a
//   *p = 20;//将通过*p找到的a的值改成20
//   printf("a = %d\n", a);//此时a的值变成20
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   char ch = 'w';
//   char* pc = &ch;
//   *pc = 'a';
//   printf("%c\n", ch);
//   return 0;
//}

//#include<stdio.h>
//int main()
//{
//   double d = 3.14;
//   double* pd = &d;
//   *pd = 5.5;
//   //%lf是C语言中double的格式字符,用于格式化输入输出
//   printf("%lf\n", d); // 直接打印出来
//   printf("%lf\n", *pd);//通过指针打印
//   return ;
//}

//指针变量的大小
//#include<stdio.h>
//int main()
//{
//   printf("%d\n", sizeof(char*));
//   printf("%d\n", sizeof(short*));
//   printf("%d\n", sizeof(int*));
//   printf("%d\n", sizeof(double*));
//   return 0;
//}
//结论：指针的大小在32位平台上是4个字节。64位平台是8个字节。

/*例12*/
//书--复杂对象
//书名+作者+出版社+定价+书号
//复杂对象 -- 用结构体来描述 -- 结构体：我们自己创造出来的类型
#include<stdio.h>
struct Book //struck结构体关键字，用于创建结构体类型。Book为类型名
{
   char name[20];//C语言程序设计
   short price;//55
}; //这个分号不可缺少，它的作用是结束定义的
int main()
{
   //利用结构体类型创建一个该类型的变量
   struct Book b1 = {"C语言程序设计", 55};
   printf("书名：%s；\n", b1.name); //. 结构体变量.成员
   printf("价格：%d元；\n", b1.price);
   b1.price = 15;
   printf("甩卖价：%d元；\n", b1.price);
   return 0;
}

//#include<stdio.h>
//#include<string.h>
//struct Book
//{
//   char name[10];
//   int price;
//};
//int main()
//{
//   struct Book b2 = {"C语言程序设计", 10};
//   strcpy(b2.name, "C++");//用于修改字符串中元素的名字。将“C语言程序设计”改为“C++”
//   //strcpy -- stringcopy -- 字符串拷贝 -- 库函数 string.h
//   b2.price = 5;
//   printf("书名：%s\n", b2.name);
//   printf("价格：%d\n", b2.price);
//   return 0;
//}

//#include <stdio.h>
//struct People
//{
//   char name[13];
//   char sex[13];
//   short years;
//};
//int main()
//{
//   struct People p = {"张三", "男", 41};
//   struct People* pd = &p;
//   printf("姓名：%s\n", pd->name);
//   printf("性别：%s\n", pd->sex);
//   printf("年龄：%d\n", pd->years);
//   return 0;
//}