1：a^a=0
  2：0^a=a
  3：异或满足交换律和结合律，即：a^b^c=a^(b^c)，a^b=b^a

int main()
{
  int a = 3;
  int b = 5;
  printf("%d %d\n", a, b);
  a = a ^ b;
  b = a ^ b;//也就是：(a^b)^b=a^(b^b)=a^0=a,此时就把a的值放到b里面去了,b里面存的就是a
  a = a ^ b;//也就是：(a^b)^a=a^a^b=0^b=b,此时就把b的值存到a里面去了，a里面存的就是b
  printf("%d %d\n", a, b);
  return 0;
}
//结果：
3 5
5 3

int weight = 120;//体重
weight = 89;//不满意就赋值
double salary = 10000.0;
salary = 20000.0;//使用赋值操作符赋值。

int a = 10;
int x = 0;
int y = 20;
a = x = y+1;//连续赋值，先把y+1的值赋值给x，再把x的值赋给a，从右往左进行赋值
//不建议这样写，可读性差，应该写成下面这样：
x=y+1;
a=x;

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

int x = 10;
x = x+10;
x += 10;//复合赋值
//其他运算符一样的道理。这样写更加简洁。

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

int main()
{
  unsigned int a = -10;//把-10放到无符号类型的变量a里面去
  //因为内存中存的是补码，这里是-10为负数，要先求出-10的补码
  //10000000000000000000000000001010（-10的原码）
  //11111111111111111111111111110101（-10的反码）
  //11111111111111111111111111110110（-10的补码）
  //此时a里面存的就是：11111111111111111111111111110110（-10的补码）
  //由于此时的a是无符号整型，所以对于a来说他就没有符号位这个概念，存在a里面的所有数都是正整数，原、反、补都一样，所以在a看来11111111111111111111111111110110就是一个原码，会直接把它转换成对应的数字
  printf("%u\n", a);//无符号整型用格式符u打印
  return 0;
}
//结果：
4294967286

//取地址符&
int main()
{
  int a = 10;
  printf("%p\n", &a);
  int* pa = &a;//取出变量a的地址放在整型指针变量pa里面
  printf("%p\n", pa);
  char ch = 'w';
  printf("%p\n", &ch);
  char* pc = &ch;//取出变量ch的地址放在字符型指针变量pc里面
  printf("%p\n", pc);
  char* p = "abcdef";//字符串常量的值其实就是首字符的地址，所以这里我们用一个字符类型的指针变量来接收
  printf("%p\n", p);
  printf("%c\n", *p);
  return 0;
}
//结果：
012FF6F8
012FF6F8
012FF6E3
012FF6E3
00F77BD0
a

//解引用操作
int main()
{
  int a = 10;
  int* pa = &a;//把a的地址放在pa变量里
  *pa=20;//通过解引用操作就可以取到a的值，并对a的值进行修改（注意：是对地址进行解引用）
  printf("%d\n", a);
  return 0;
}

int main()
{
  *(int*)0x0012ff40=10;//随便编写了一个地址对其进行解引用是非法的
  return 0;
}

int main()
{
  int a = 10;
  printf("%d\n", sizeof(a));//计算一个变量的大小
  printf("%d\n", sizeof a);//这里可以不带括号，说明sizeof不是函数，因为函数即使没有参数也要带括号
  printf("%d\n", sizeof(int));//计算一个类型的大小，这里sizeof后面的括号不能省略
  int arr[10] = { 0 };
  printf("%d\n", sizeof arr);//计算一个数组的大小
  printf("%d\n", sizeof(int[10]));//其中int [10]是数组arr的类型
  return 0;
}

int main()
{
  int a = 10;
  short s = 5;
  printf("%d\n", sizeof(s = a + 3));//a+3=13赋给s的这个动作是不会发生的，如果一个整形的数据非要放到一个短整型里会发生截断，所以最终的大小还是s说了算
  printf("%d\n", s);
  return 0;
}
//结果：
2
5

//~按位取反
int main()
{
  int a = 0;
  //00000000000000000000000000000000
  //11111111111111111111111111111111（按位取反，得到的是一个补码）
  //10000000000000000000000000000000
  //10000000000000000000000000000001（打印时需要的原码）
  printf("%d\n", ~a);//结果就是-1
  return 0;
}

//综合练习
int main()
{
  int a = 9;
  //00000000000000000000000000001001
  //把9的二进制位第五位上的0变成1
  //首先想到按位或操作
  //00000000000000000000000000010000  其实就是：1<<4
  //00000000000000000000000000011001（按位或的结果就是我们想要的）,其实就是25
  a |= (1 << 4);
  printf("%d\n", a);//打印出来的就是25
  //把a的二进制中的第五位改回来，变0
  //00000000000000000000000000011001
  // 可以用异或操作
  //00000000000000000000000000010000    其实就是：1<<4
  //00000000000000000000000000001001（按位异或的结果就是我们想要的）
  a ^= (1 << 4);
  printf("%d\n", a);
  //还可以利用按位与操作
  //00000000000000000000000000011001
  //11111111111111111111111111101111   其实就是：~(1<<4)
  //00000000000000000000000000001001（按位与的结果就是我们想要的）
  a &= ~(1 << 4);
  printf("%d\n", a);
  return 0;
}
//结果：
25
9
9

int main()
{
  int a = 10;
  int b = a++;//后置++，先使用，再++
  //相当于：int b=a;a=a+1;
  printf("a=%d\n", a);
  printf("b=%d\n", b);
  return 0;
}
//结果：
a=11
b=10

int main()
{
  int a = 10;
  int b = ++a;//先进行++操作，再把a加之后的值赋值给b
  printf("a=%d\n", a);
  printf("b=%d\n", b);
  return 0;
}
//结果：
a=11
b=11

int main()
{
  int a = 10;
  int b = ++a;//b=11,a=11
  int a = 10;
  int b = a + 1;//b=11,a=10
  return 0;
}

int main()
{
  int a = (int)3.14;//把一个浮点型强制转化成整型，直接取整数部分，不会进行四舍五入
  printf("%d\n", a);
  return 0;
}

void test1(int arr[])//数组传参，形参可以写成数组，也可以写成指针
{
  printf("%zd\n", sizeof(arr));//(2)这里其实是计算整型指针的大小，在×86（32位机）的环境下指针的大小是4个字节
}
void test2(char ch[])
{
  printf("%zd\n", sizeof(ch));//(4)这里的ch本质上也是指针，所以在×86（32位机）的环境下大小还是4个字节
}
int main()
{
  int arr[10] = { 0 };
  char ch[10] = { 0 };
  printf("%zd\n", sizeof(arr));//(1)计算的是数组的大小，单位是字节10*4=40
  printf("%zd\n", sizeof(ch));//(3)计算的是数组的大小，单位是字节10*1=10
  test1(arr);//数组名是首元素地址
  test2(ch);//数组名是首元素地址
  return 0;
}
//结果：
40
10
4
4

void test1(int arr[], int sz)//数组传参，形参用数组来接收
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
  printf("\n");
}
void test2(int* arr, int sz)//数组传参，形参用指针来接收
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);//这里的arr[i]其实就是*(arr+i),加i就是跳过i个整型，然后解引用
  }
  printf("\n");
}
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int sz = sizeof(arr) / sizeof(arr[0]);
  test1(arr, sz);
  test2(arr, sz);
  return 0;
}
//结果：
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

>
>=
<
<=
!=      用于测试“不相等”
==      用于测试“相等”

 &&    逻辑与
 ||    逻辑或

int main()
{
  int i = 0, a = 0, b = 2, c = 3, d = 4;
  i = a++ && ++b && d++;//其中a++的值是0，因为后面都是逻辑与，并且a++的值为0，对于逻辑与来说，只要有0结果就一定是0，所以此时后面是什么值已经不重要了，不会再执行后面的表达式了，因此就只执行了a++这个表达式
  //对于逻辑与，只要左边为假，右边就不再计算
  //对于逻辑与，只要左边为真，右边就不再计算
  //i = a++||++b||d++;
  printf("a = %d\nb = %d\n
c = %d\nd = %d\n", a, b, c, d);
  return 0;
}   
//结果：
a = 1
b = 2
c = 3
d = 4

//把a和b的较大值赋值给m
int main()
{
  int a = 10;
  int b = 20;
  int m = 0;
  if (a > b)
    m = a;
  else
    m = b;
  m = (a > b ? a : b);//利用条件操作符来实现
  return 0;
}

//逗号表达式
int main()
{
  //代码1
  int a = 1;
  int b = 2;
  int c = (a > b, a = b + 10, a, b = a + 1);//逗号表达式,从左到右依次计算，整个逗号表达式的结果是最后一个表达式的结果
  printf("%d\n", c);//c最终是13
  return 0;
}
//结果：
13
//代码2
if (a =b + 1, c=a / 2, d > 0)//最终决定if真假的是最后一个表达式d>0,但如果前面的表达式中出现了d,就会影响最终d>0的结果，因此还是要老老实实的从左往右计算
//代码3
a = get_val();
count_val(a);
while (a > 0)
{
//业务处理
        a = get_val();
        count_val(a);
}
//如果使用逗号表达式，改写：
while (a = get_val(), count_val(a), a>0)
{
         //业务处理
}

//下标引用操作符
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  printf("%d\n", arr[4]);//[]就是下标引用操作符
  return 0;
}

//函数调用操作符
int main()
{
  int len = strlen("abcdef");//()就是函数调用操作符，操作数：strlen,"abcdef".对于函数调用操作符来说至少有一个操作数函数名（函数没有参数的时候），
  return 0;
}

  .  结构体变量.成员名
  -> 结构体指针->成员名

//结构成员访问操作符
//结构体——自定义类型（聚合体）
//生活中有些对象要被描述，不能简单的使用单个内置类型
//书：书名，作者，出版社，定价，……
//类型
struct Book
{
  char name[20];
  char author[30];
  int price;
};
void print1(struct Book* p)
{
  printf("《%s》%s %d\n", (*p).name, (*p).author, (*p).price);
  printf("《%s》%s %d\n", p->name,p->author,p->price);//结构体指针->成员名
}
int main()
{
  struct Book b1 = { "大话数据结构","佚名",66 };
  struct Book b2 = { "C语言","佚名",65 };
  printf("《%s》%s %d\n", b1.name, b1.author, b1.price);//结构体变量.成员名
  printf("《%s》%s %d\n", b2.name, b2.author, b2.price);
  print1(&b1);
  return 0;
}

//整型提升
//char short int long……
//  1    2    4
//整型提升针对的是类型的字节数小于整形的，char或者short类型的变量在参与运算的时候，首先会把它们提升为整型
int main()
{
  //当前编译器（vs）char-->signed char（有符号的char，所以它的最高位就是符号位）
  char a = 3;//首先3是一个整数，那它一定是4个字节
  //00000000000000000000000000000011，要把这个存到a里面去，但是a是一个字符型，就只有一个字节，肯定存不下这么多，只能存下最右边的八个比特位
  //00000011 - a中存的
  //四个字节的数据非要放到一个字节的变量里面去，这叫截断
  char b = 127;
  //00000000000000000000000001111111
  //11111111 - b中存的
  char c = a + b;//在计算的时候，首先会把a和b转化为int类型，转化完之后再去加，加的结果也是一个int类型，最终把这个int类型的结果放到c里面
  //00000011 - a中存的
  //01111111 - b中存的
  //接下来就要发生整型提升
  //00000000000000000000000000000011 -- a经过提升后
  //00000000000000000000000001111111 -- b经过提升后
  //接下来就可以进行相加的操作了
  //00000000000000000000000010000010 -- a+b的结果
  //要把这个（四个字节）存到c（字符型，一个字节）里面去，会发生截断
  //10000010 -- c中存的
  printf("%d\n", c);
  //%d -- 打印十进制的整数，所以这里以%d来打印一个字符型变量c也会进行整型提升
  //10000010 -- c中存的
  //11111111111111111111111110000010 -- c经过提升后，注意：这还是内存中存储的，所以这一串二进制是补码，而我们打印需要的是原码
  //10000000000000000000000001111101 -- 符号位不变，其他位按位取反、
  //10000000000000000000000001111110 -- 原码(+1)
  //对应二进制：-126
  return 0;
}
//结果：
-126

  补充：char - - 有符号的char的取值范围是：-128~127
                 无符号的char的取值范围是：0~255  
      short - - 有符号的short的取值范围是：-32768~32767
                无符号的short的取值范围是：0~65535

//整型提升的例子:
int main()
{
  char a = 0xb6;//对应二进制：10110110
  //00000000000000000000000010110110 -- 0xb6
  //10110110 -- a中存的
  short b = 0xb600;
  int c = 0xb6000000;
  if (a == 0xb6)
  //这里：a == 0xb6 是一个表达式，在对表达式进行计算的时候，就会进行整型提升
  //10110110 -- a中存的
  //接下来要对a进行整型提升
  //11111111111111111111111110110110 -- a经过整型提升后
  //00000000000000000000000010110110 -- 0xb6
  //显然：a和0xb6并不相等，所以 表达式：a == 0xb6 的值位假，就不会执行下面的打印a
    printf("a\n");
  if (b == 0xb600)
    printf("b\n");
  if (c == 0xb6000000)//这里c本来就是整型，所以就不会进行整型提升
    printf("c\n");
  return 0;
}
//结果：
c

//实例2
int main()
{
  char c = 1;
  printf("%u\n", sizeof(c));
  printf("%u\n", sizeof(+c));//这里+c就是一个表达式，只要是表达式，在参与运算的时候就会进行整型提升，提升之后就变成四个字节了
  printf("%u\n", sizeof(-c));
  return 0;
}
//结果：
1
4
4

  long double
  double
  float
  unsigned long int
  long int
  unsigned int
  int

  1.操作符的优先级
  2.操作符的结合性
  3.是否控制求值顺序

int c=3;
c + --c;
//情形一：
//+左边的c在--c之前就准备好了，此时+左边的c就是3，--c的结果就是2，此时c + --c的结果就是5.
//情形二：
//+左边的c在--c之后才准备好，此时先执行--c，--c的结果是2，此时c变成2，然后+左边的c开始准备，所以+左边的c就是2，此时表达式c + --c的值就是4

//问题代码
int fun()
{
    static int count = 1;
    return ++count;
}
//第一次调用返回2，第二次调用返回3，第三次调用返回4
int main()
{
    int answer;
    answer = fun() - fun() * fun();
    //这里我们只能知道 * 比 + 先算，但是不知道这三个fun函数到底哪一个最先调用
    printf("%d\n", answer);//输出多少？
    return 0;
}

//问题代码
int main()
{
  int i = 1;
  int ret = (++i) + (++i) + (++i);
  printf("%d\n", ret);
  printf("%d\n", i);
  return 0;
}