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

int flag=1；
if（!flag）// 等同于 if（0）
printf（"hehe");
这里会输出 呵呵 嘛？答案是不会的
！为逻辑反操作符，意味真的变成假的，假的变成真的。

#include<stdio.h>
int main()
{
  int a = 5;
  printf("%p\n", &a);//取出a这个值存储再内存中的地址
}

#include<stdio.h>
int main()
{
  int a = 5;
  printf("%p\n", &a);//取出a这个值存储再内存中的地址
}

#include<stdio.h>
#include<string.h>
int main()
{
  int a[]={1,2,3,4,5};
  printf("%d\n", sizeof(a));//  20
  int 类型占四个字节，一共有5个元素，因此在内存中占20 byte
  char b[] = { 1,2,3,4, 5}；
  printf("%d\n", sizeof(b));//  5
  char 类型占一个字节，一共五个元素，因此在内存中占 5 byte
  int c[]="abcd";
    printf("%d\n",sizeof(c)); // 5
    abcd \0，这个字符串后面有一个\0，用sizeof计算内存大小，\0也会被计算进去
}

#include<stdio.h>
int main()
{
    printf("%zu\n", sizeof(int));  // 4
    printf("%zu\n", sizeof(char)); // 1
    printf("%zu\n", sizeof(double));// 8
    printf("%zu\n", sizeof(float));// 4
    return 0;
}

#include<stdio.h>
#include<string.h>
int main()
{
  char a[] = "abcd";
  对于字符串，它的结尾有一个 \0
  printf("%d\n", strlen(a));  // 因此结果为 4
    char b[] = { 1,2,3,4,5 };
    对于这个数组而言，当读到 5 过后，编译器并不知道这个数组里 \0 再何处
    只能一直往下读取，直到\0出现才返回之前的字符长度，因此是随机值
    printf("%d\n", strlen(b));  // 随机值
  char c[] = { 1,2,3,'\0',4,5 };
  原本这个数组的字符串长度是一个随机值，但是由于我们手动往里填加了\0,
  因此，再读到第三位过后就遇到了\0，返回之前的三个数的字符长度，结果为3
    printf("%d\n", strlen(c));  // 3
}

#include <stdio.h>
int main()
{
    int a = 10;
    int x = ++a;
    //先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。
    int y = --a;
    //先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;
    return 0; }
    上述代码如果理解不清楚，可以按如下理解
    int a=10；
    //int x=++a;
    可以写成
    a=a+1;此时 a=11;
    int x=a； //x=11
   同理：
    //int =y=--a;可以写成
    a=a-1;此时a使用的是上面++a后a的值 -- a=10;
    int y=a;// y=10

    int a=10;
    int x=a++;
    //先使用a，然后再自增。先使用a时，x=10；之后自增，a=11；
    int y=a--;
    //先使用a，然后自增。先使用a时，由于上面++a后的影响，现在a=11；
    //先使用a，则y=11；在自减，a=10；
    若对上述代码理解不清楚，可以按如下理解
    int a=10;
    //int x=a++;
    可以写成
    int x=a; //x=10;
    a=a+1; //a=11;
    同理：
    //int y=a--;
    int y=a;//由于上述a++的影响，此时a已经变成了11
            //先使用a，则y=11；
    a=a-1;  //a=10；

#include<stdio.h>
int main()
{
    int a = 10;
    int* p = &a;//p当中存储的是a的地址
    p = 0;//由于p中存的是a的地址，改变P的值，也就间接的改变了a地址里的值
    printf("%d", a);
    return 0;
}

void print(int* arr)
{
    printf("%d", *(arr+1));
       //arr相当于首元素地址，+1 向后跳过一个整形找到第二个元素
       //等同于arr[1]，所以打印的结果应该是2
}
#include<stdio.h>
int main()
{
    int arr[5] = { 1,2,3,4,5 };
    print(arr); //数组传参传的是首元素地址
    return 0;
}

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
int main()
{
    srand((unsigned int) time(NULL));
    //随机数的起点设置我们用时间戳来表示--time函数，它的返回类型是time_t
    //因此我们需要将它强制类型转换成和X的类型一致。
    int x = rand();//使用随机数时，需要设置一个随机数的生成起点
    printf("%d", x);
    return 0;
}

&&     逻辑与
||     逻辑或

#include <stdio.h>
int main()
{
    int i = 0,a=0,b=2,c =3,d=4;
    （表达式）&&（表达式）这是&&的使用形式，因此我们在这不需要考虑
    前置++和后置++的优先级比&&高的问题。他们都是表达式的情况下，优先级
    相同，此时只需要按照&&的结合方式从左往右结合。
    i = a++ && ++b && d++;
    根据上面介绍的前置后置++的用法
    a先使用在++，a=0  我们知道，对于表达式结果为0，则是一个假命题，&&只要
    有一个假则结果为假，那么a++&&++b =0 同理 0&&d++=0 ，因此++b 和d++ 
    表达式都没有执行
    此时 a=1 b=2 c=3 d=4
    printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
    return 0;
}

#include <stdio.h>
int main()
{
    int i = 0,a=0,b=2,c =3,d=4;
    同样，||和&&一样，是表达式之间的使用形式，在这也不用考虑优先级
    i = a++||++b||d++;
    a先使用，后++，a=0，对于||，两边为假结果才为假，还需要看表达式++b；
    b先++ 后使用，b=3；则a++||++b结果为真
    那么，a++||++b||d++，前面为真，无论d++ 是否为真结果一定是真，因此d++不执行
    此时，a=1 b=3，c=3，d=4
    printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
    return 0; 
}

表达式1 ? 表达式2 : 表达式3

#include<stidio.h>
int main()
{
   int a=1;
   if(a>2)
     a=1;
   else
     a=-1;
   return 0;
}
更改为条件表达式则为
#include<stdio.h>
int main()
{ 
   int a=1;
   (a>2)?(a=1):(a=-1);
   return 0;
}

#include<stdio.h>
int main()
{
  int a=1；
  int b=2；
  int max=（a>b）?a:b;
  //通过一个条件操作符，我们很容易就能得出两个数的大小关系
  printf("%d",max);
  return 0;
}

表达式1, 表达式2, 表达式3, …表达式N

int a = 1;
int b = 2;
if (a =b + 1, c=a / 2, d > 0)
可以看到if（）里面是一个逗号表达式，最终结果为最有一个表达式结果
等同于if（d>0）

int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);//逗号表达式
括号里面是逗号表达式，但是c并不是直接为b=a+1=2；
逗号表达式从左往右依次执行中，由于前面的表达式中的值影响了最后a的值，
因此最后结果并不直接为2，a=b+10=12， b=a+1=12+1=13；
最终结果为13

[ ]  下标引用操作符

()  函数调用符

int Add(int x, int y)
{
  return x + y;
}
#include<stdio.h>
int main()
{
  int a = 1;
  int b = 2;
  int c = Add(a, b);
  对于Add这个函数来说，函数调用操作符（），它的操作数首先是函数名Add
  其次是里面的传给函数的参数，a和b
  对于操作的参数可以是多个
  printf("%d", c);
}

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

#include<stdio.h>
#include<string.h>
struct Book //定义一个书的结构体
{
  char name[20]; //这本书构成的内容包括书名
  short price;  // 价格
};
int main()
{
  struct Book b1 = { "C语言程序设计",55 };
  //结构体中 b1这本书规定它的书名和价格
  b1.price = 55;//规定价格
  strcpy(b1.name, "C语言程序设计");//规定书名
当我们b1 这本书已经构建好以后，我们该怎么获取这本书里的价格和书名信息呢？
通过 结构体.成员名的形式
   b1 -- 结构体
   prince和name 都是成员名
  printf("价格：%d\n", b1.price);
  printf("书名：%s\n", b1.name);
    return 0;
}

#include<stdio.h>
#include<string.h>
struct Book
{
  char name[20];
  short price;
};
int main()
{
  struct Book b1 = { "C语言程序设计",55 };
  b1.price = 55;
  strcpy(b1.name, "C语言程序设计");
  struct Book* pb = &b1;//获取结构体中 b1这本书的地址
  printf("书名：%s\n", (*pb).name);    // . 结构体变量.成员
  printf("价格：%d\n", (*pb).price);
  由于*（pb）存放了b1这个接头体的地址，因此*（pb）也可以认为是一个结构体变量，同理它也可以用上述方式访问里面的成员
  printf("书名：%s\n", pb->name);       // -> 结构体指针 ->成员
  printf("价格：%d\n", pb->price);
  pb是一个指针，可以由指针-> 直接访问结构体成员
    return 0;
}