int p; //这是一个普通的整型变量
int *p; //首先从P 处开始,先与*结合,所以说明P 是一个指针,然后再与int 结合,说明指针所指向的内容的类型为int 型.所以P是一个返回整型数据的指针
int p[3]; //首先从P 处开始,先与[]结合,说明P 是一个数组,然后与int 结合,说明数组里的元素是整型的,所以P 是一个由整型数据组成的数组
int *p[3]; //首先从P 处开始,先与[]结合,因为其优先级比*高,所以P 是一个数组,然后再与*结合,说明数组里的元素是指针类型,然后再与int 结合,说明指针所指向的内容的类型是整型的,所以P 是一个由返回整型数据的指针所组成的数组
int (*p)[3]; //首先从P 处开始,先与*结合,说明P 是一个指针然后再与[]结合(与"()"这步可以忽略,只是为了改变优先级),说明指针所指向的内容是一个数组,然后再与int 结合,说明数组里的元素是整型的.所以P 是一个指向由整型数据组成的数组的指针
int **p; //首先从P 开始,先与*结合,说是P 是一个指针,然后再与*结合,说明指针所指向的元素是指针,然后再与int 结合,说明该指针所指向的元素是整型数据.由于二级指针以及更高级的指针极少用在复杂的类型中,所以后面更复杂的类型我们就不考虑多级指针了,最多只考虑一级指针.
int p(int); //从P 处起,先与()结合,说明P 是一个函数,然后进入()里分析,说明该函数有一个整型变量的参数,然后再与外面的int 结合,说明函数的返回值是一个整型数据
int (*p)(int); //从P 处开始,先与指针结合,说明P 是一个指针,然后与()结合,说明指针指向的是一个函数,然后再与()里的int 结合,说明函数有一个int 型的参数,再与最外层的int 结合,说明函数的返回类型是整型,所以P 是一个指向有一个整型参数且返回类型为整型的函数的指针
int *(*p(int))[3]; //可以先跳过,不看这个类型,过于复杂从P 开始,先与()结合,说明P 是一个函数,然后进入()里面,与int 结合,说明函数有一个整型变量参数,然后再与外面的*结合,说明函数返回的是一个指针,,然后到最外面一层,先与[]结合,说明返回的指针指向的是一个数组,然后再与*结合,说明数组里的元素是指针,然后再与int 结合,说明指针指向的内容是整型数据.所以P 是一个参数为一个整数据且返回一个指向由整型指针变量组成的数组的指针变量的函数.

char a[20];
int *p=(int *)a; //强制类型转换并不会改变a 的类型
p++;

int a = 4, b;
int *p;

p = &a;//&是取地址
b = *p; //*是取内容

int a, b;
int array[10];
int *pa;
int **ptr;

pa = &a;
ptr = &pa;//pa是int型指针，&pa就是指针的指针
*ptr = &b;//二级指针取内容，就是一个一级指针

char *arr[20];//arr是char*指针类型的数组
char **parr = arr;

char *str[3]={
    "Hello,thisisasample!",
    "Hi,goodmorning.",
    "Helloworld"
};
char s[80]；
strcpy(s,str[0]); //也可写成strcpy(s,*str);
strcpy(s,str[1]); //也可写成strcpy(s,*(str+1));
strcpy(s,str[2]); //也可写成strcpy(s,*(str+2));

struct MyStruct
{
    int a;
    int b;
    int c;
};
struct MyStruct ss={20,30,40};
//声明了结构对象ss，并把ss的成员初始化为20，30 和40。
struct MyStruct *ptr=&ss;
//声明了一个指向结构对象ss 的指针。它的类型是
//MyStruct *,它指向的类型是MyStruct。

ptr->a;
ptr->b;
ptr->c;

int fun(char *,int);
int (*pfun)(char *,int);//pfun是个函数指针
pfun=fun;
int a=(*pfun)("abcdefg",7); //用运算符*取内容，后面加上形参就能调用函数了。

unsigned int a;
a=0x12345678;//表示一个具体地址
char *ptr;
ptr=(char*)a;

int a=123,b;
int *ptr=&a;
char *str;
b=(int)ptr; //把指针ptr 的值当作一个整数取出来。
str=(char*)b; //把这个整数的值当作一个地址赋给指针str。

char s='a';
int *ptr;
ptr=(int *)&s;
*ptr=1298;

#include<stdio.h>

struct ListNode {
    int val;
    struct ListNode *next;
};

void main()
{
    struct ListNode* l1 = malloc(sizeof(struct ListNode));
    struct ListNode* l2 = malloc(sizeof(struct ListNode));
    l1->val = 2;
    l2->val = 6;
    l1->next = l2;
    printf("%d\r\n",l1->val);
    printf("%d\r\n",l1->next->val);
    printf("%d\r\n",(int)l1->next->next);
    printf("%d\r\n",(int)NULL);
    if (l1->next->next==NULL)
    {
        printf("111");
    }
    
}

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode* head=NULL;
    struct ListNode* node=NULL;
    int carry = 0;
    while(l1 || l2)
    {
        int c1 = l1? l1->val : 0;
        int c2 = l2? l2->val : 0;
        if(head==NULL)
        {
            head = node = malloc(sizeof(struct ListNode));
            node->val = (c1+c2+carry)%10;
            node->next = NULL;
        }
        else
        {
            node->next = malloc(sizeof(struct ListNode));
            node = node->next;
            node->val = (c1+c2+carry)%10;
            node->next = NULL;
        }
        if(l1)l1 = l1->next;
        if(l2)l2 = l2->next;

        carry = (c1+c2+carry)/10;
    }
    if(carry!=0)
    {
        node->next = malloc(sizeof(struct ListNode));//这四步其实可以看作一步，就简单了很多,代码模块化
        node = node->next;
        node->val = carry;
        node->next = NULL;
    }
    return head;
}

head = node = malloc(sizeof(struct ListNode));

node->next = malloc(sizeof(struct ListNode));//这四步其实可以看作一步，就简单了很多,代码模块化
node = node->next;
node->val = carry;
node->next = NULL;

#define max(a,b) a>b? a : b

int lengthOfLongestSubstring(char* s) {

    int left = 0,length = 0,max_l = 0;
    for(int right=0; s[right];right++)
    {
        for(int i=left ; i<right ; i++)
        {
            if(s[i]==s[right])
            {
                left=i+1;       
            }

        }
        length = right+1 - left;
        max_l = max(length,max_l);
    }
    return max_l;
    
}

/* USER CODE BEGIN CAN_Init 2 */
CAN_FilterTypeDef can_filtercfg;
can_filtercfg.FilterMode = CAN_FILTERMODE_IDMASK;//屏蔽位模式
can_filtercfg.FilterScale = CAN_FILTERSCALE_32BIT;
can_filtercfg.FilterIdHigh = 0x12<<5;//ID
can_filtercfg.FilterIdLow = 0;
can_filtercfg.FilterMaskIdHigh = 0x7FF;
can_filtercfg.FilterMaskIdLow = 0x06;

can_filtercfg.FilterBank = 0;//过滤器组0
can_filtercfg.FilterFIFOAssignment = CAN_FILTER_FIFO0;
can_filtercfg.FilterActivation = CAN_FILTER_ENABLE;
can_filtercfg.SlaveStartFilterBank = 14;//如果只使用单个CAN，可忽略此成员取值：0 ~ 27
while(HAL_CAN_ConfigFilter(&hcan, &can_filtercfg)!=HAL_OK);
/* USER CODE END CAN_Init 2 */