内核链表list.h文件剖析

 

内核链表list.h文件剖析

一、内核链表的结构【双向循环链表】

    内核链表的好主要体现为两点，1是可扩展性，2是封装。可以将内核链表复用到用户态编程中，以后在用户态下编程就不需要写一些关于链表的代码了，直接将内核中list.h中的代码拷贝过来用。

struct list_head
{struct list_head *next, *prev;
}; // 包含了两个指向list_head结构体的指针next,prev[后驱和前驱]

 

二、内核链表常用接口

1、INIT_LIST_HEAD：创建链表

2、list_add：在prev和next之间插入结点

3、list_add_tail：在链表尾插入结点

4、list_del：删除结点

5、list_entry：取出结点

6、list_for_each：遍历链表

【推荐看使用sourceInsight查看代码】

 

三、深入分析list.h

1、offsetof【在已知某一个成员变量的名字和结构体类型的情况下，计算该成员相对于结构体的起始地址的偏移量】

#ifdef __compiler_offsetof
#define offsetof(TYPE,MEMBER)__compiler_offsetof(TYPE,MEMBER)
#else
#ifndef offsetof
#define offsetof(type, member) ((size_t) &((type*)0)->member)
#endif

 

2、container_of【已知某一个成员变量的名字、指针和结构体类型的情况下，计算结构体的指针，也就是计算结构体的起始地址】

#define container_of(ptr, type, member) ({ \const typeof(((type *)0)->member ) *__mptr = (ptr); \(type *)((char *)__mptr - offsetof(type,member) );})

 

3、LIST_HEAD_INIT【初始化一个结点名字为name的双向循环链表的头结点】

#define LIST_HEAD_INIT(name) { &(name),&(name) }

 

4、LIST_HEAD【初始化一个结点名字为name的双向循环链表的头结点】

#define LIST_HEAD(name) \struct list_head name = LIST_HEAD_INIT(name)

 

5、INIT_LIST_HEAD【初始化链表节点，将next和prev指针都指向其自身，我们就构造了一个空的双循环链表。】

static __INLINE__ void INIT_LIST_HEAD(struct list_head *list)
{list->next= list;list->prev= list;
}

 

6、list_add【在头结点后加一个新结点】

#ifndef CONFIG_DEBUG_LIST
static __INLINE__ void __list_add(struct list_head *new,struct list_head *prev,struct list_head *next)
{next->prev= new;new->next =next;new->prev =prev;prev->next= new;
}
#else
extern void __list_add(struct list_head *new,struct list_head *prev,struct list_head *next);
#endifstatic __INLINE__ void list_add(struct list_head *new,struct list_head *head)
{__list_add(new, head, head->next);
}

 

7、list_add_tail【添加结点new到链表尾】

static __INLINE__ void list_add_tail(struct list_head *new, struct list_head *head)
{__list_add(new, head->prev, head);
} // 在head->prev和head之间加入new，即在链表尾加入new结点

 

8、list_del【list_del将会将该节点与外界的“联系”切断，然后就可以使用free释放了（如果是内核态就用kfree或vfree）】

#define LIST_POISON1 0
#define LIST_POISON2 0static __INLINE__ void __list_del(struct list_head *prev, struct list_head * next)
{next->prev= prev;prev->next= next;
}#ifndef CONFIG_DEBUG_LIST
static __INLINE__ void list_del(struct list_head *entry)
{__list_del(entry->prev, entry->next);entry->next= LIST_POISON1;entry->prev= LIST_POISON2;
}
#else
extern void list_del(struct list_head *entry);
#endif

 

9、list_replace【用结点new替换结点old】

static __INLINE__ void list_replace(struct list_head *old,struct list_head *new)
{new->next =old->next;new->next->prev = new;new->prev =old->prev;new->prev->next = new;
}

 

10、 list_replace_init【用结点new替换结点old，并初始化old】

static __INLINE__ void list_replace_init(struct list_head *old,struct list_head *new)
{list_replace(old, new);INIT_LIST_HEAD(old);
}

 

11、list_del_init【删除结点entry，并初始化entry】

static __INLINE__ void list_del_init(struct list_head*entry)
{__list_del(entry->prev, entry->next);INIT_LIST_HEAD(entry);
}

 

12、list_move【先将list节点从原链表中删除，然后将其添加到head链表的表头】

static __INLINE__ void list_move(struct list_head *list, struct list_head *head)
{__list_del(list->prev, list->next);list_add(list,head);
}

 

13、list_move_tail【先将list节点从原链表中删除，然后将其添加到head链表的表尾】

static __INLINE__ void list_move_tail(struct list_head *list,struct list_head *head)
{__list_del(list->prev, list->next);list_add_tail(list, head);
}

 

14、list_is_last【测试list节点是否为head链表的表尾节点。是返回1，否则返回0】

static __INLINE__ int list_is_last(const struct list_head *list,const struct list_head *head)
{return list->next == head;
}

 

15、list_empty【判断head链表是否为空链表，是返回1，否则返回为0】

static __INLINE__ int list_empty(const struct list_head *head)
{return head->next == head;
}


16、list_empty_careful【判断节点head的前驱和后驱是否都指向head。是返回1，否则返回0】

static __INLINE__ int list_empty_careful(const structlist_head *head)
{struct list_head *next = head->next;return (next== head) && (next == head->prev);
}


17、list_rotate_left【函数每次将头结点后的一个结点放到head链表的末尾，直到head结点后没有其他结点】

static __INLINE__ void list_rotate_left(struct list_head *head)
{struct list_head *first;if(!list_empty(head)){first =head->next;list_move_tail(first, head);}
}

 

18、list_is_singular【判断head链表是否为单节点链表。是返回1，否为0】

static __INLINE__ int list_is_singular(const struct list_head *head)
{return !list_empty(head) && (head->next == head->prev);
}

 

19、__list_cut_position【这个函数是将head链表的头结点至entry节点之间的节点连在list节点后面，即组成以list节点为头结点的新链表】

static __INLINE__ void __list_cut_position(struct list_head *list,struct list_head *head, struct list_head *entry)
{struct list_head *new_first = entry->next;list->next= head->next;list->next->prev = list;list->prev= entry;entry->next= list;head->next= new_first;new_first->prev = head;
}<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>


20、list_cut_position【与__list_cut_position功能相似，不过要先判断链表head是否为空链表，再判断是否为了单链表而且节点不是entry的情况，如果head==entry，直接初始化list】

static __INLINE__ void list_cut_position(struct list_head *list,struct list_head *head, struct list_head *entry)
{if(list_empty(head)){return;}if(list_is_singular(head) &&(head->next != entry && head != entry)){return;}if (entry ==head){INIT_LIST_HEAD(list);}else{__list_cut_position(list, head, entry);}
}

 

21、__list_splice【将list链表的全部节点（头节点list除外）插入在prev和next节点之间】

static __INLINE__ void __list_splice(const struct list_head *list,struct list_head *prev,struct list_head *next)
{struct list_head *first = list->next;struct list_head *last = list->prev;first->prev= prev;prev->next= first;last->next= next;next->prev= last;
}

 

22、list_splice_tail【在list是非空链表的情况下，将其插在head链表的尾部，即head节点的前面】

static __INLINE__ void list_splice_tail(struct list_head *list,struct list_head *head)
{if(!list_empty(list)){__list_splice(list, head->prev, head);}
}

 

23、list_splice_init【在list是非空链表的情况下，将其插在head链表的尾部，即head节点的前面。然后对list节点进行初始化，排除不安全因素】

static __INLINE__ void list_splice_init(struct list_head *list,struct list_head *head)
{if(!list_empty(list)){__list_splice(list, head, head->next);INIT_LIST_HEAD(list);}
}

 

24、list_splice_tail_init【在list是非空链表的情况下，将其插在head链表的尾部，即head节点的前面。然后对list节点进行初始化，排除不安全因素】

static __INLINE__ void list_splice_tail_init(struct list_head *list, struct list_head *head)
{if(!list_empty(list)){__list_splice(list, head->prev, head);INIT_LIST_HEAD(list);}
}

 

25、list_entry【获取type类型结构体的起始指针】

#define list_entry(ptr, type, member) \container_of(ptr, type, member)

 

26、list_first_entry【已知type类型的结构体中member成员的指针后，求得它所在的链表的下一个指针所指的member所在的type类型的结构体的起始地址】

#define list_first_entry(ptr, type, member) \list_entry((ptr)->next, type, member)

 

27、list_for_each【从head节点开始（不包括head节点）遍历它的每一个节点】

#define list_for_each(pos, head) \for (pos =(head)->next; prefetch(pos->next), pos != (head); \pos =pos->next)

 

28、list_for_each_prev【它也是从head节点开始（不包括head节点）向前遍历每一个节点！即从链表的尾部开始遍历】

#define list_for_each_prev(pos, head) \for (pos =(head)->prev; prefetch(pos->prev), pos != (head); \pos =pos->prev)

 

29、list_for_each_safe【从head节点开始（不包括head节点！）遍历它的每一个节点！它用n先将下一个要遍历的节点保存起来，防止删除本节点后，无法找到下一个节点，而出现错误】

#define list_for_each_safe(pos, n, head) \for (pos =(head)->next, n = pos->next; pos != (head); \pos = n, n =pos->next)

 

30、list_for_each_prev_safe【它也是从head节点开始（不包括head节点）向前遍历每一个节点！即从链表的尾部开始遍历】

#define list_for_each_prev_safe(pos, n, head) \for (pos =(head)->prev, n = pos->prev; \prefetch(pos->prev), pos != (head); \pos = n,n = pos->prev)

 

31、list_for_each_entry【已知指向某个结构体的指针pos，以及指向它中member成员的指针head，从下一个结构体开始向后遍历这个结构体链】

#define list_for_each_entry(pos, head, member)        \for (pos =list_entry((head)->next, typeof(*pos), member);  \prefetch(pos->member.next), &pos->member != (head);  \pos = list_entry(pos->member.next,typeof(*pos), member))

 

32、list_for_each_entry_reverse【已知指向某个结构体的指针pos，以及指向它中member成员的指针head，从下一个结构体开始向前遍历这个结构体链】

#define list_for_each_entry_reverse(pos, head,member)      \for (pos =list_entry((head)->prev, typeof(*pos), member);  \prefetch(pos->member.prev), &pos->member != (head);  \pos =list_entry(pos->member.prev, typeof(*pos), member))

 

33、list_prepare_entry【判断pos这个指针是否为空，为空的话给它赋值list_entry(head, typeof(*pos), member)这条语句求出来的结构体的地址】

#define list_prepare_entry(pos, head, member) \((pos) ? :list_entry(head, typeof(*pos), member))

 

34、list_for_each_entry_continue【已知指向某个结构体的指针pos，以及指向它中的member成员的head指针，从它的下一个结构体开始向后遍历这个链表】

#define list_for_each_entry_continue(pos, head,member)     \for (pos =list_entry(pos->member.next, typeof(*pos), member);  \prefetch(pos->member.next), &pos->member != (head);  \pos =list_entry(pos->member.next, typeof(*pos), member))

 

35、list_for_each_entry_continue_reverse【已知指向某个结构体的指针pos，以及指向它中的member成员的head指针，从它的前一个结构体开始向前遍历这个链表】

#define list_for_each_entry_continue_reverse(pos,head, member)   \for (pos =list_entry(pos->member.prev, typeof(*pos), member);  \prefetch(pos->member.prev), &pos->member != (head);  \pos =list_entry(pos->member.prev, typeof(*pos), member))

 

36、list_for_each_entry_from【从pos节点开始，向后遍历链表】

#define list_for_each_entry_from(pos, head,member)       \for (;prefetch(pos->member.next), &pos->member != (head);  \pos =list_entry(pos->member.next, typeof(*pos), member))

 

37、list_for_each_entry_safe【先保存下一个要遍历的节点！从head下一个节点向后遍历链表】

#define list_for_each_entry_safe(pos, n, head,member)      \for (pos =list_entry((head)->next, typeof(*pos), member),  \n =list_entry(pos->member.next, typeof(*pos), member); \&pos->member != (head);         \pos = n,n = list_entry(n->member.next, typeof(*n), member))

 

38、list_for_each_entry_safe_continue【先保存下一个要遍历的节点！从pos下一个节点向后遍历链表】

#define list_for_each_entry_safe_continue(pos, n, head,member)     \for (pos =list_entry(pos->member.next, typeof(*pos), member),    \n =list_entry(pos->member.next, typeof(*pos), member);   \&pos->member != (head);           \pos = n,n = list_entry(n->member.next, typeof(*n), member))

 

39、list_for_each_entry_safe_from【先保存下一个要遍历的节点！从pos节点向后遍历链表】

#define list_for_each_entry_safe_from(pos, n, head,member)       \for (n =list_entry(pos->member.next, typeof(*pos), member);    \&pos->member != (head);           \pos = n, n = list_entry(n->member.next,typeof(*n), member))

 

40、list_for_each_entry_safe_reverse【先保存下一个要遍历的节点！从链表尾部向前遍历链表】

#define list_for_each_entry_safe_reverse(pos, n, head,member)    \for (pos =list_entry((head)->prev, typeof(*pos), member),  \n =list_entry(pos->member.prev, typeof(*pos), member); \&pos->member != (head);         \pos = n,n = list_entry(n->member.prev, typeof(*n), member))

 

41、list_safe_reset_next【获取n结构体指针】

#define list_safe_reset_next(pos, n, member)        \n =list_entry(pos->member.next, typeof(*pos), member)

 

// hash链表头
struct hlist_head
{structh list_node *first;
};struct hlist_node
{struct hlist_node *next, **pprev;
};

1、INIT_HLIST_HEAD【初始化头节点指针ptr】

#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)

 

2、INIT_HLIST_NODE【初始化hlist节点】

static __INLINE__ void INIT_HLIST_NODE(struct hlist_node *h)
{h->next =NULL;h->pprev =NULL;
}

 

3、hlist_unhashed【判断h->pprev是否为空，是返回1，否返回0】

static __INLINE__ int hlist_unhashed(const struct hlist_node *h)
{return !h->pprev;
}

 

4、hlist_empty【判断hlist是否为空，是返回1，否返回0】

static __INLINE__ int hlist_empty(const struct hlist_head *h)
{return !h->first;
}

 

5、__hlist_del【删除结点n】

static __INLINE__ void __hlist_del(struct hlist_node*n)
{struct hlist_node *next = n->next;struct hlist_node **pprev = n->pprev;*pprev = next;if (next){next->pprev = pprev;}
}

 

6、hlist_del【删除结点n，将结点next、pprev分别指向LIST_POISON1、LIST_POISON2。这样设置是为了保证不在链表中的结点项不能被访问】

static __INLINE__ void hlist_del(struct hlist_node *n)
{__hlist_del(n);n->next =LIST_POISON1;n->pprev =LIST_POISON2;
}

 

7、hlist_del_init【先判断结点是否为空，不为空删除，再初始化节点】

static __INLINE__ void hlist_del_init(struct hlist_node *n)
{if(!hlist_unhashed(n)){__hlist_del(n);INIT_HLIST_NODE(n);}
}

 

8、hlist_add_head【增加结点n到h表头】

static __INLINE__ void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
{struct hlist_node *first = h->first;n->next =first;if (first){first->pprev = &n->next;}h->first =n;n->pprev =&h->first;
}<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>


9、hlist_add_before【增加结点n到结点next之前】

/* next must be != NULL */
static __INLINE__ void hlist_add_before(struct hlist_node *n,struct hlist_node *next)
{n->pprev =next->pprev;n->next = next;next->pprev= &n->next;*(n->pprev)= n;
}

 

10、hlist_add_after【增加结点n到结点next之后】

static __INLINE__ void hlist_add_after(struct hlist_node *n,struct hlist_node *next)
{next->next= n->next;n->next =next;next->pprev= &n->next;if(next->next){next->next->pprev  =&next->next;}
}

 

11、hlist_move_list【头结点new接管头结点old的所有节点，并初始化old】

static __INLINE__ void hlist_move_list(struct hlist_head *old,struct hlist_head *new)
{new->first= old->first;if(new->first){new->first->pprev = &new->first;}old->first= NULL;
}

 

12、hlist_entry【已知某一个成员变量的名字、指针和结构体类型的情况下，计算结构体的指针，也就是计算结构体的起始地址】

#define hlist_entry(ptr, type, member) container_of(ptr,type,member)

13、hlist_for_each【遍历hlist链表】

#define hlist_for_each(pos, head) \for (pos =(head)->first; pos ; \pos =pos->next)

 

14、 hlist_for_each_safe【遍历hlist链表，一般在删除结点使用】

#define hlist_for_each_safe(pos, n, head) \for (pos =(head)->first; pos && ({ n = pos->next; 1; }); \pos = n)

 

15、hlist_for_each_entry【遍历找typeof(*tpos)的结构体类型入口地址】

#define hlist_for_each_entry(tpos, pos, head,member)      \for (pos =(head)->first;          \pos&& ({ prefetch(pos->next); 1;}) &&      \({ tpos =hlist_entry(pos, typeof(*tpos), member); 1;}); \pos =pos->next)

 

16、hlist_for_each_entry_continue【从结点pos下一个遍历找typeof(*tpos)的结构体类型入口地址】

#define hlist_for_each_entry_continue(tpos, pos,member)     \for (pos =(pos)->next;            \pos&& ({ prefetch(pos->next); 1;}) &&      \({ tpos =hlist_entry(pos, typeof(*tpos), member); 1;}); \pos =pos->next)

 

17、hlist_for_each_entry_from【从节点pos开始遍历找typeof(*tpos)的结构体类型入口地址】

#define hlist_for_each_entry_from(tpos, pos,member)       \for (; pos&& ({ prefetch(pos->next); 1;}) &&      \({ tpos =hlist_entry(pos, typeof(*tpos), member); 1;}); \pos =pos->next)

 

18、hlist_for_each_entry_safe【从头节点head开始遍历找typeof(*tpos)的结构体类型入口地址】

#define hlist_for_each_entry_safe(tpos, pos, n, head,member)      \for (pos =(head)->first;          \pos&& ({ n = pos->next; 1; }) &&         \({ tpos =hlist_entry(pos, typeof(*tpos), member); 1;}); \pos = n)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/466460.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

CAN总线很难吗？CAN总线看不懂是不可能的！

CAN总线很难吗？CAN总线看不懂是不可能的！

CAN&#xff08;Controller Area Network&#xff09;即控制器局域网&#xff0c;是一种能够实现分布式实时控制的串行通信网络。想到CAN就要想到德国的Bosch公司&#xff0c;因为CAN就是这个公司开发的&#xff08;和Intel&#xff09;CAN有很多优秀的特点&#xff0c;使得它能…
阅读更多...
GetDlgItem

GetDlgItem

GetDlgItemText() GetDlgItemText是C中的函数&#xff0c;调用这个函数以获得与对话框中的控件相关的标题或文本。GetDlgItemText成员函数将文本拷贝到lpStr指向的位置并返回拷贝的字节的数目。 函数说明 CWnd类的成员函数。 函数原型 int GetDlgItemText( HWND hDlg , int n…
阅读更多...
开放课程管理系统(Moodle)的介绍(转)

开放课程管理系统(Moodle)的介绍(转)

一、虚拟学习环境 关于虚拟学习环境&#xff0c;很难用一个简单的定义来描述。可以说是&#xff0c;支持和管理教与学的各项活动的基于网络的环境。也可以认为是学习管理系统的组成部分。当应用于远程教育时&#xff0c;通常认为它包括“任何用于创造一个统一的、类似于面对面的…
阅读更多...
C语言必须写main函数？最简单的 Hello world 你其实一点都不懂！

C语言必须写main函数？最简单的 Hello world 你其实一点都不懂！

我们在刚写程序的时候&#xff0c;第一个都是 hello world&#xff0c;而在这里&#xff0c;完整的代码就是&#xff1a;我们打眼一看&#xff0c;其实很简单&#xff0c;就是引入头文件&#xff0c;写一个主函数&#xff0c;然后输出一句话&#xff0c;但是当我们编译出来ELF的…
阅读更多...
内核链表使用举例

内核链表使用举例

内核链表使用举例#ifndef _EVENT_LIST_H_ #define _EVENT_LIST_H_#include "list.h" // 内核链表头文件typedef int (*event_cb)(void *data);typedef struct {void *params;event_cb handle;struct list_head list; } event_elem_t;int EventListAdd(event_elem_t *…
阅读更多...
CObList

CObList

CObList CObList类支持非唯一的CObject指针&#xff0c;并可顺次访问或通过指针值访问有序列表。CObList列表的行为类似于双向链接列表。CObList是非常有用的集合类族的代表&#xff0c;具有诊断转储的特性并且能够包含混合的指针。 POSITION类型的变量为列表的键。使用POSITIO…
阅读更多...
源码包安装

源码包安装

一、源码包和RPM包的区别 1、区别 安装之前的区别&#xff1a;概念上的区别 安装之后的区别&#xff1a;安装位置不同 2、RPM包安装位置 是安装在默认位置中 注&#xff1a;安装位置是写RPM包的作者决定的 注&#xff1a;RPM包支持指定安装位置&#xff0c;但是不建议指定位置安…
阅读更多...
年轻10岁简单又易行的妙方

年轻10岁简单又易行的妙方

爱美的女性&#xff0c;谁不想使自己更年轻&#xff0c;并能留住一份健康的美?我们介绍的方法非常容易实现&#xff0c;只要你能够坚持。想要年轻10岁?没有想象中那么困难,但是也要持之以恒哦!这里推荐的都是价廉易置的)鉴借&#xff0c;愿能给大家有参考之用&#xff1a;1.一…
阅读更多...
计算最后一个单词的字符串长度

计算最后一个单词的字符串长度

题目 http://www.nowcoder.com/questionTerminal/8c949ea5f36f422594b306a2300315da 看了大家的答案&#xff0c;觉得还是稍微复杂。给一个比骄简单的解题思路。 只要是空格&#xff0c;就把计数置0&#xff0c;要不然就一直自增。 #include "stdio.h" #include …
阅读更多...
strstrsubstr、AfxGetApp

strstrsubstr、AfxGetApp

1.strstr(str1,str2) 函数用于判断字符串str2是否是str1的子串。如果是&#xff0c;则该函数返回str2在str1中首次出现的地址&#xff1b;否则&#xff0c;返回NULL。 2.substr是C语言函数&#xff0c;主要功能是复制子字符串&#xff0c;要求从指定位置开始&#xff0c;并具有…
阅读更多...
Linux下修改SSH登录端口

Linux下修改SSH登录端口

Linux下修改SSH登录端口LINUX 的默认SSH 端口是 22。为了防止别人暴力破解&#xff0c;建议修改SSH 访问端口&#xff1a;vim /etc/ssh/sshd_config 找到Port 22 这一行&#xff0c;这是是默认端口22&#xff0c;现在改成Port 1234这个数字自己定&#xff0c;但是不要超过65536…
阅读更多...
五岁的时候，你在干什么？

五岁的时候，你在干什么？

文章写在2021.2.7号——想不到啊想不到&#xff0c;这么快你就五岁了。今天是楠哥的生日&#xff0c;在五年前的今天&#xff0c;小伙子在深圳宝安妇幼出生&#xff0c;刚出生的时候&#xff0c;样子很丑&#xff0c;第一次见面&#xff0c;我心情很紧张&#xff0c;不怎么敢靠…
阅读更多...
GetLocalTime

GetLocalTime

GetLocalTime是一个Windows API 函数&#xff0c;用来获取当地的当前系统日期和时间。 函数原型: VOID GetLocalTime( LPSYSTEMTIME lpSystemTime //address of system times structure ); 参数说明: lpSystemTime: 指向一个用户自定义包含日期和时间信息的类型为 SYSTEMTIME 的…
阅读更多...
Java集合(7)：散列与散列码

Java集合(7)：散列与散列码

散列的价值在于速度。我们使用数组来保存键的信息&#xff0c;这个信息并不是键本身&#xff0c;而是通过键对象生成一个数字(散列码)&#xff0c;作为数组下标。由于数组的容量是固定的&#xff0c;而散列容器的大小是可变的&#xff0c;所以不同的键可以产生相同的数组下标(散…
阅读更多...
301转向代码合集

301转向代码合集

教育资源网将SEO工作中所需要的301转向代码进行了整理&#xff0c;收藏并分享&#xff0c;以备查阅。 1、IIS下301设置 Internet信息服务管理器 -> 虚拟目录 -> 重定向到URL&#xff0c;输入需要转向的目标URL&#xff0c;并选择“资源的永久重定向”。 2、ASP下的301转向…
阅读更多...
TQ210——核心板和底板

TQ210——核心板和底板

TQ210——核心板和底板 1、TQ210简介【TQ210_COREB核心板 TQ210_BOARD_V4底板】 三星Cortex-A8 S5PV210芯片&#xff0c;运行最大频率1GHZ&#xff0c;处理器内部为64/32位总线结构&#xff0c;32/32KB一级缓存&#xff0c;512KB二级缓存。自带3D加速引擎&#xff08;SGX540&a…
阅读更多...
“华为天才少年”自制百大Up奖杯，网友：技术难度不高侮辱性极强

“华为天才少年”自制百大Up奖杯，网友：技术难度不高侮辱性极强

来源&#xff1a;雷锋网B站硬核黑科技Up主、AI算法工程师稚晖君&#xff0c;停更了好一阵子后&#xff0c;这位自称野生钢铁侠的超硬核Up主终于又发布了新作品。之所以停更这么久&#xff0c;Up主解释说&#xff0c;不是因为在野外被捕了&#xff0c;纯粹是因为工作太忙了。熟悉…
阅读更多...
CListBox的函数

CListBox的函数

CListBox::GetCurSel 函数原型&#xff1a; int GetCursel( ) const; 返回值&#xff1a; 从当前选中的项的索引为零开始。如果没有项目被当前选定或如果列表框是一个多次选择列表框&#xff0c;则返回LB_ERR。 说明&#xff1a; 从当前选中的项的索引为零开始,如果任何的,在…
阅读更多...
终极教程，带具体实验现象，1个GPIO控制2个LED显示4种状态，欢迎讨论！

终极教程，带具体实验现象，1个GPIO控制2个LED显示4种状态，欢迎讨论！

芯片之家前几天发了一篇文章&#xff0c;讨论1个GPIO控制2个LED显示4种状态&#xff0c;并没有带具体的实验现象&#xff0c;有点小遗憾&#xff1a;绝妙&#xff01;1个GPIO控制2个LED显示4种状态&#xff0c;什么&#xff1f;你不信&#xff1f;&#xff08;点击阅读&#xf…
阅读更多...
【转载】AE表达式中英文对照

【转载】AE表达式中英文对照

全局对象 Comp comp(name) 用另一个名字给合成命名。 Footage footage(name) 用另一个名字给脚本标志命名。 Comp thisComp 描述合成内容的表达式。例如&#xff1a;thisComp.layer(2) Layer, Light, or Camera thisLayer 是对层本身的描述&#xff0c;thisLayer是一个默认的对…
阅读更多...
最新文章

Copyright @ 2022~2023