data_support/utlist（关于编译器的一些宏宏设置）

2023-11-09

#ifndef UTLIST_H //tlist 权限查看程序

#define UTLIST_H

#define UTLIST_VERSION 1.9.8

#include <assert.h>

* This file contains macros to manipulate（操作） singly（逐一的直截了当的） and doubly-linked（双链的） lists.

* 1. LL_ macros: singly-linked lists. //单链宏

* 2. DL_ macros: doubly-linked lists. //双链宏

* 3. CDL_ macros: circular doubly-linked lists. //环链宏

* To use singly-linked lists, your structure must have a "next" pointer. //单链节点内需要一个next

* To use doubly-linked lists, your structure must "prev" and "next" pointers. //双链需要 pref next

* Either way, the pointer to the head of the list must be initialized to NULL. //头指针为0

* --------------------------------------------------

* For doubly-linked lists, the append（附加） and delete macros are O(1)

* For singly-linked lists, append and delete are O(n) but prepend（预先考虑） is O(1)

* The sort macro is O(n log(n)) for all types of single/double/circular lists.

/* These macros use decltype or the earlier __typeof GNU（调试器） extension(延长伸展，扩展).

As decltype is only available（可用的） in newer compilers (VS2010 or gcc 4.3+

when compiling（编译） c++ code), this code uses whatever method is needed

or, for VS2008 where neither is available, uses casting workarounds（工作区）. */

#ifdef _MSC_VER /* MS compiler */

#if _MSC_VER >= 1600 && defined(__cplusplus) /* VS2010 or newer in C++ mode */

#define LDECLTYPE(x) decltype(x) //在C++中，decltype作为操作符，用于查询表达式的数据类型

#else /* VS2008 or older (or VS2010 in C mode) */

#define NO_DECLTYPE

#define LDECLTYPE(x) char*

#endif

#else /* GNU, Sun and other compilers */

#define LDECLTYPE(x) __typeof(x)

#endif

_MSC_VER 定义编译器的版本。下面是一些编译器版本的_MSC_VER值（参见扩展阅读中的参考文献2的链接）

MS VC++ 11.0_MSC_VER = 1700 (Visual C++ 2012)

MS VC++ 10.0 _MSC_VER = 1600

MS VC++ 9.0 _MSC_VER = 1500

MS VC++ 8.0 _MSC_VER = 1400

MS VC++ 7.1 _MSC_VER = 1310

MS VC++ 7.0 _MSC_VER = 1300

MS VC++ 6.0 _MSC_VER = 1200

MS VC++ 5.0 _MSC_VER = 1100

其中MS VC++ 10.0就是Visual C++ 2010，MS VC++ 9.0就是Visual C++ 2008，MS VC++ 8.0就是Visual C++ 2005。

/* for VS2008 we use some workarounds to get around（到处走走；逃避，传开来） the lack（不足） of decltype,

* namely（换句话说）, we always reassign（再分配） our tmp variable to the list head if we need

* to dereference（废弃） its prev/next pointers, and save/restore the real head.*/

#ifdef NO_DECLTYPE

#define _SV(elt,list) _tmp = (char*)(list); {char **_alias = (char**)&(list); *_alias = (elt); }

#define _NEXT(elt,list,next) ((char*)((list)->next))

#define _NEXTASGN(elt,list,to,next) { char **_alias = (char**)&((list)->next); *_alias=(char*)(to); }

/* #define _PREV(elt,list,prev) ((char*)((list)->prev)) */

#define _PREVASGN(elt,list,to,prev) { char **_alias = (char**)&((list)->prev); *_alias=(char*)(to); }

#define _RS(list) { char **_alias = (char**)&(list); *_alias=_tmp; }

#define _CASTASGN(a,b) { char **_alias = (char**)&(a); *_alias=(char*)(b); }

#else

#define _SV(elt,list)

#define _NEXT(elt,list,next) ((elt)->next)

#define _NEXTASGN(elt,list,to,next) ((elt)->next)=(to)

/* #define _PREV(elt,list,prev) ((elt)->prev) */

#define _PREVASGN(elt,list,to,prev) ((elt)->prev)=(to)

#define _RS(list)

#define _CASTASGN(a,b) (a)=(b)

#endif

/******************************************************************************

* The sort macro is an adaptation of Simon Tatham's O(n log(n)) mergesort *

* Unwieldy variable names used here to avoid shadowing passed-in variables. *

*****************************************************************************/

#define LL_SORT(list, cmp) \

LL_SORT2(list, cmp, next)

#define LL_SORT2(list, cmp, next) \

do { \

LDECLTYPE(list) _ls_p; \

LDECLTYPE(list) _ls_q; \

LDECLTYPE(list) _ls_e; \

LDECLTYPE(list) _ls_tail; \

int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping; \

if (list) { \

_ls_insize = 1; \

_ls_looping = 1; \

while (_ls_looping) { \

_CASTASGN(_ls_p,list); \

list = NULL; \

_ls_tail = NULL; \

_ls_nmerges = 0; \

while (_ls_p) { \

_ls_nmerges++; \

_ls_q = _ls_p; \

_ls_psize = 0; \

for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) { \

_ls_psize++; \

_SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list); \

if (!_ls_q) break; \

} \

_ls_qsize = _ls_insize; \

while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) { \

if (_ls_psize == 0) { \

_ls_e = _ls_q; _SV(_ls_q,list); _ls_q = \

_NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; \

} else if (_ls_qsize == 0 || !_ls_q) { \

_ls_e = _ls_p; _SV(_ls_p,list); _ls_p = \

_NEXT(_ls_p,list,next); _RS(list); _ls_psize--; \

} else if (cmp(_ls_p,_ls_q) <= 0) { \

_ls_e = _ls_p; _SV(_ls_p,list); _ls_p = \

_NEXT(_ls_p,list,next); _RS(list); _ls_psize--; \

} else { \

_ls_e = _ls_q; _SV(_ls_q,list); _ls_q = \

_NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; \

} \

if (_ls_tail) { \

_SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e,next); _RS(list); \

} else { \

_CASTASGN(list,_ls_e); \

} \

_ls_tail = _ls_e; \

} \

_ls_p = _ls_q; \

} \

if (_ls_tail) { \

_SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,NULL,next); _RS(list); \

} \

if (_ls_nmerges <= 1) { \

_ls_looping=0; \

} \

_ls_insize *= 2; \

} \

} while (0)

#define DL_SORT(list, cmp) \

DL_SORT2(list, cmp, prev, next)

#define DL_SORT2(list, cmp, prev, next) \

do { \

LDECLTYPE(list) _ls_p; \

LDECLTYPE(list) _ls_q; \

LDECLTYPE(list) _ls_e; \

LDECLTYPE(list) _ls_tail; \

int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping; \

if (list) { \

_ls_insize = 1; \

_ls_looping = 1; \

while (_ls_looping) { \

_CASTASGN(_ls_p,list); \

list = NULL; \

_ls_tail = NULL; \

_ls_nmerges = 0; \

while (_ls_p) { \

_ls_nmerges++; \

_ls_q = _ls_p; \

_ls_psize = 0; \

for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) { \

_ls_psize++; \

_SV(_ls_q,list); _ls_q = _NEXT(_ls_q,list,next); _RS(list); \

if (!_ls_q) break; \

} \

_ls_qsize = _ls_insize; \

while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) { \

if (_ls_psize == 0) { \

_ls_e = _ls_q; _SV(_ls_q,list); _ls_q = \

_NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; \

} else if (_ls_qsize == 0 || !_ls_q) { \

_ls_e = _ls_p; _SV(_ls_p,list); _ls_p = \

_NEXT(_ls_p,list,next); _RS(list); _ls_psize--; \

} else if (cmp(_ls_p,_ls_q) <= 0) { \

_ls_e = _ls_p; _SV(_ls_p,list); _ls_p = \

_NEXT(_ls_p,list,next); _RS(list); _ls_psize--; \

} else { \

_ls_e = _ls_q; _SV(_ls_q,list); _ls_q = \

_NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; \

} \

if (_ls_tail) { \

_SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e,next); _RS(list); \

} else { \

_CASTASGN(list,_ls_e); \

} \

_SV(_ls_e,list); _PREVASGN(_ls_e,list,_ls_tail,prev); _RS(list); \

_ls_tail = _ls_e; \

} \

_ls_p = _ls_q; \

} \

_CASTASGN(list->prev, _ls_tail); \

_SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,NULL,next); _RS(list); \

if (_ls_nmerges <= 1) { \

_ls_looping=0; \

} \

_ls_insize *= 2; \

} \

} while (0)

#define CDL_SORT(list, cmp) \

CDL_SORT2(list, cmp, prev, next)

#define CDL_SORT2(list, cmp, prev, next) \

do { \

LDECLTYPE(list) _ls_p; \

LDECLTYPE(list) _ls_q; \

LDECLTYPE(list) _ls_e; \

LDECLTYPE(list) _ls_tail; \

LDECLTYPE(list) _ls_oldhead; \

LDECLTYPE(list) _tmp; \

int _ls_insize, _ls_nmerges, _ls_psize, _ls_qsize, _ls_i, _ls_looping; \

if (list) { \

_ls_insize = 1; \

_ls_looping = 1; \

while (_ls_looping) { \

_CASTASGN(_ls_p,list); \

_CASTASGN(_ls_oldhead,list); \

list = NULL; \

_ls_tail = NULL; \

_ls_nmerges = 0; \

while (_ls_p) { \

_ls_nmerges++; \

_ls_q = _ls_p; \

_ls_psize = 0; \

for (_ls_i = 0; _ls_i < _ls_insize; _ls_i++) { \

_ls_psize++; \

_SV(_ls_q,list); \

if (_NEXT(_ls_q,list,next) == _ls_oldhead) { \

_ls_q = NULL; \

} else { \

_ls_q = _NEXT(_ls_q,list,next); \

} \

_RS(list); \

if (!_ls_q) break; \

} \

_ls_qsize = _ls_insize; \

while (_ls_psize > 0 || (_ls_qsize > 0 && _ls_q)) { \

if (_ls_psize == 0) { \

_ls_e = _ls_q; _SV(_ls_q,list); _ls_q = \

_NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; \

if (_ls_q == _ls_oldhead) { _ls_q = NULL; } \

} else if (_ls_qsize == 0 || !_ls_q) { \

_ls_e = _ls_p; _SV(_ls_p,list); _ls_p = \

_NEXT(_ls_p,list,next); _RS(list); _ls_psize--; \

if (_ls_p == _ls_oldhead) { _ls_p = NULL; } \

} else if (cmp(_ls_p,_ls_q) <= 0) { \

_ls_e = _ls_p; _SV(_ls_p,list); _ls_p = \

_NEXT(_ls_p,list,next); _RS(list); _ls_psize--; \

if (_ls_p == _ls_oldhead) { _ls_p = NULL; } \

} else { \

_ls_e = _ls_q; _SV(_ls_q,list); _ls_q = \

_NEXT(_ls_q,list,next); _RS(list); _ls_qsize--; \

if (_ls_q == _ls_oldhead) { _ls_q = NULL; } \

} \

if (_ls_tail) { \

_SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_ls_e,next); _RS(list); \

} else { \

_CASTASGN(list,_ls_e); \

} \

_SV(_ls_e,list); _PREVASGN(_ls_e,list,_ls_tail,prev); _RS(list); \

_ls_tail = _ls_e; \

} \

_ls_p = _ls_q; \

} \

_CASTASGN(list->prev,_ls_tail); \

_CASTASGN(_tmp,list); \

_SV(_ls_tail,list); _NEXTASGN(_ls_tail,list,_tmp,next); _RS(list); \

if (_ls_nmerges <= 1) { \

_ls_looping=0; \

} \

_ls_insize *= 2; \

} \

} while (0)

/******************************************************************************

* singly linked list macros (non-circular) *

*****************************************************************************/

#define LL_PREPEND(head,add) \

LL_PREPEND2(head,add,next)

#define LL_PREPEND2(head,add,next) \

do { \

(add)->next = head; \

head = add; \

} while (0)

#define LL_CONCAT(head1,head2) \

LL_CONCAT2(head1,head2,next)

#define LL_CONCAT2(head1,head2,next) \

do { \

LDECLTYPE(head1) _tmp; \

if (head1) { \

_tmp = head1; \

while (_tmp->next) { _tmp = _tmp->next; } \

_tmp->next=(head2); \

} else { \

(head1)=(head2); \

} \

} while (0)

#define LL_APPEND(head,add) \

LL_APPEND2(head,add,next)

#define LL_APPEND2(head,add,next) \

do { \

LDECLTYPE(head) _tmp; \

(add)->next=NULL; \

if (head) { \

_tmp = head; \

while (_tmp->next) { _tmp = _tmp->next; } \

_tmp->next=(add); \

} else { \

(head)=(add); \

} \

} while (0)

#define LL_DELETE(head,del) \

LL_DELETE2(head,del,next)

#define LL_DELETE2(head,del,next) \

do { \

LDECLTYPE(head) _tmp; \

if ((head) == (del)) { \

(head)=(head)->next; \

} else { \

_tmp = head; \

while (_tmp->next && (_tmp->next != (del))) { \

_tmp = _tmp->next; \

} \

if (_tmp->next) { \

_tmp->next = ((del)->next); \

} \

} while (0)

/* Here are VS2008 replacements for LL_APPEND and LL_DELETE */

#define LL_APPEND_VS2008(head,add) \

LL_APPEND2_VS2008(head,add,next)

#define LL_APPEND2_VS2008(head,add,next) \

do { \

if (head) { \

(add)->next = head; /* use add->next as a temp variable */ \

while ((add)->next->next) { (add)->next = (add)->next->next; } \

(add)->next->next=(add); \

} else { \

(head)=(add); \

} \

(add)->next=NULL; \

} while (0)

#define LL_DELETE_VS2008(head,del) \

LL_DELETE2_VS2008(head,del,next)

#define LL_DELETE2_VS2008(head,del,next) \

do { \

if ((head) == (del)) { \

(head)=(head)->next; \

} else { \

char *_tmp = (char*)(head); \

while ((head)->next && ((head)->next != (del))) { \

head = (head)->next; \

} \

if ((head)->next) { \

(head)->next = ((del)->next); \

} \

{ \

char **_head_alias = (char**)&(head); \

*_head_alias = _tmp; \

} \

} while (0)

#ifdef NO_DECLTYPE

#undef LL_APPEND

#define LL_APPEND LL_APPEND_VS2008

#undef LL_DELETE

#define LL_DELETE LL_DELETE_VS2008

#undef LL_DELETE2

#define LL_DELETE2_VS2008

#undef LL_APPEND2

#define LL_APPEND2 LL_APPEND2_VS2008

#undef LL_CONCAT /* no LL_CONCAT_VS2008 */

#undef DL_CONCAT /* no DL_CONCAT_VS2008 */

#endif

/* end VS2008 replacements */

#define LL_FOREACH(head,el) \

LL_FOREACH2(head,el,next)

#define LL_FOREACH2(head,el,next) \

for(el=head;el;el=(el)->next)

#define LL_FOREACH_SAFE(head,el,tmp) \

LL_FOREACH_SAFE2(head,el,tmp,next)

#define LL_FOREACH_SAFE2(head,el,tmp,next) \

for((el)=(head);(el) && (tmp = (el)->next, 1); (el) = tmp)

#define LL_SEARCH_SCALAR(head,out,field,val) \

LL_SEARCH_SCALAR2(head,out,field,val,next)

#define LL_SEARCH_SCALAR2(head,out,field,val,next) \

do { \

LL_FOREACH2(head,out,next) { \

if ((out)->field == (val)) break; \

} \

} while(0)

#define LL_SEARCH(head,out,elt,cmp) \

LL_SEARCH2(head,out,elt,cmp,next)

#define LL_SEARCH2(head,out,elt,cmp,next) \

do { \

LL_FOREACH2(head,out,next) { \

if ((cmp(out,elt))==0) break; \

} \

} while(0)

#define LL_REPLACE_ELEM(head, el, add) \

do { \

LDECLTYPE(head) _tmp; \

assert(head != NULL); \

assert(el != NULL); \

assert(add != NULL); \

(add)->next = (el)->next; \

if ((head) == (el)) { \

(head) = (add); \

} else { \

_tmp = head; \

while (_tmp->next && (_tmp->next != (el))) { \

_tmp = _tmp->next; \

} \

if (_tmp->next) { \

_tmp->next = (add); \

} \

} while (0)

#define LL_PREPEND_ELEM(head, el, add) \

do { \

LDECLTYPE(head) _tmp; \

assert(head != NULL); \

assert(el != NULL); \

assert(add != NULL); \

(add)->next = (el); \

if ((head) == (el)) { \

(head) = (add); \

} else { \

_tmp = head; \

while (_tmp->next && (_tmp->next != (el))) { \

_tmp = _tmp->next; \

} \

if (_tmp->next) { \

_tmp->next = (add); \

} \

} while (0) \

/******************************************************************************

* doubly linked list macros (non-circular) *

*****************************************************************************/

#define DL_PREPEND(head,add) \

DL_PREPEND2(head,add,prev,next)

#define DL_PREPEND2(head,add,prev,next) \

do { \

(add)->next = head; \

if (head) { \

(add)->prev = (head)->prev; \

(head)->prev = (add); \

} else { \

(add)->prev = (add); \

} \

(head) = (add); \

} while (0)

#define DL_APPEND(head,add) \

DL_APPEND2(head,add,prev,next)

#define DL_APPEND2(head,add,prev,next) \

do { \

if (head) { \

(add)->prev = (head)->prev; \

(head)->prev->next = (add); \

(head)->prev = (add); \

(add)->next = NULL; \

} else { \

(head)=(add); \

(head)->prev = (head); \

(head)->next = NULL; \

} \

} while (0)

#define DL_CONCAT(head1,head2) \

DL_CONCAT2(head1,head2,prev,next)

#define DL_CONCAT2(head1,head2,prev,next) \

do { \

LDECLTYPE(head1) _tmp; \

if (head2) { \

if (head1) { \

_tmp = (head2)->prev; \

(head2)->prev = (head1)->prev; \

(head1)->prev->next = (head2); \

(head1)->prev = _tmp; \

} else { \

(head1)=(head2); \

} \

} while (0)

#define DL_DELETE(head,del) \

DL_DELETE2(head,del,prev,next)

#define DL_DELETE2(head,del,prev,next) \

do { \

assert((del)->prev != NULL); \

if ((del)->prev == (del)) { \

(head)=NULL; \

} else if ((del)==(head)) { \

(del)->next->prev = (del)->prev; \

(head) = (del)->next; \

} else { \

(del)->prev->next = (del)->next; \

if ((del)->next) { \

(del)->next->prev = (del)->prev; \

} else { \

(head)->prev = (del)->prev; \

} \

} while (0)

#define DL_FOREACH(head,el) \

DL_FOREACH2(head,el,next)

#define DL_FOREACH2(head,el,next) \

for(el=head;el;el=(el)->next)

/* this version is safe for deleting the elements during iteration */

#define DL_FOREACH_SAFE(head,el,tmp) \

DL_FOREACH_SAFE2(head,el,tmp,next)

#define DL_FOREACH_SAFE2(head,el,tmp,next) \

for((el)=(head);(el) && (tmp = (el)->next, 1); (el) = tmp)

/* these are identical to their singly-linked list counterparts */

#define DL_SEARCH_SCALAR LL_SEARCH_SCALAR

#define DL_SEARCH LL_SEARCH

#define DL_SEARCH_SCALAR2 LL_SEARCH_SCALAR2

#define DL_SEARCH2 LL_SEARCH2

#define DL_REPLACE_ELEM(head, el, add) \

do { \

assert(head != NULL); \

assert(el != NULL); \

assert(add != NULL); \

if ((head) == (el)) { \

(head) = (add); \

(add)->next = (el)->next; \

if ((el)->next == NULL) { \

(add)->prev = (add); \

} else { \

(add)->prev = (el)->prev; \

(add)->next->prev = (add); \

} \

} else { \

(add)->next = (el)->next; \

(add)->prev = (el)->prev; \

(add)->prev->next = (add); \

if ((el)->next == NULL) { \

(head)->prev = (add); \

} else { \

(add)->next->prev = (add); \

} \

} while (0)

#define DL_PREPEND_ELEM(head, el, add) \

do { \

assert(head != NULL); \

assert(el != NULL); \

assert(add != NULL); \

(add)->next = (el); \

(add)->prev = (el)->prev; \

(el)->prev = (add); \

if ((head) == (el)) { \

(head) = (add); \

} else { \

(add)->prev->next = (add); \

} \

} while (0) \

/******************************************************************************

* circular doubly linked list macros *

*****************************************************************************/

#define CDL_PREPEND(head,add) \

CDL_PREPEND2(head,add,prev,next)

#define CDL_PREPEND2(head,add,prev,next) \

do { \

if (head) { \

(add)->prev = (head)->prev; \

(add)->next = (head); \

(head)->prev = (add); \

(add)->prev->next = (add); \

} else { \

(add)->prev = (add); \

(add)->next = (add); \

} \

(head)=(add); \

} while (0)

#define CDL_DELETE(head,del) \

CDL_DELETE2(head,del,prev,next)

#define CDL_DELETE2(head,del,prev,next) \

do { \

if ( ((head)==(del)) && ((head)->next == (head))) { \

(head) = 0L; \

} else { \

(del)->next->prev = (del)->prev; \

(del)->prev->next = (del)->next; \

if ((del) == (head)) (head)=(del)->next; \

} \

} while (0)

#define CDL_FOREACH(head,el) \

CDL_FOREACH2(head,el,next)

#define CDL_FOREACH2(head,el,next) \

for(el=head;el;el=((el)->next==head ? 0L : (el)->next))

#define CDL_FOREACH_SAFE(head,el,tmp1,tmp2) \

CDL_FOREACH_SAFE2(head,el,tmp1,tmp2,prev,next)

#define CDL_FOREACH_SAFE2(head,el,tmp1,tmp2,prev,next) \

for((el)=(head), ((tmp1)=(head)?((head)->prev):NULL); \

(el) && ((tmp2)=(el)->next, 1); \

((el) = (((el)==(tmp1)) ? 0L : (tmp2))))

#define CDL_SEARCH_SCALAR(head,out,field,val) \

CDL_SEARCH_SCALAR2(head,out,field,val,next)

#define CDL_SEARCH_SCALAR2(head,out,field,val,next) \

do { \

CDL_FOREACH2(head,out,next) { \

if ((out)->field == (val)) break; \

} \

} while(0)

#define CDL_SEARCH(head,out,elt,cmp) \

CDL_SEARCH2(head,out,elt,cmp,next)

#define CDL_SEARCH2(head,out,elt,cmp,next) \

do { \

CDL_FOREACH2(head,out,next) { \

if ((cmp(out,elt))==0) break; \

} \

} while(0)

#define CDL_REPLACE_ELEM(head, el, add) \

do { \

assert(head != NULL); \

assert(el != NULL); \

assert(add != NULL); \

if ((el)->next == (el)) { \

(add)->next = (add); \

(add)->prev = (add); \

(head) = (add); \

} else { \

(add)->next = (el)->next; \

(add)->prev = (el)->prev; \

(add)->next->prev = (add); \

(add)->prev->next = (add); \

if ((head) == (el)) { \

(head) = (add); \

} \

} while (0)

#define CDL_PREPEND_ELEM(head, el, add) \

do { \

assert(head != NULL); \

assert(el != NULL); \

assert(add != NULL); \

(add)->next = (el); \

(add)->prev = (el)->prev; \

(el)->prev = (add); \

(add)->prev->next = (add); \

if ((head) == (el)) { \

(head) = (add); \

} \

} while (0) \

#endif /* UTLIST_H */

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

cocos2dxsupport

data_support/utlist（关于编译器的一些宏宏设置）的相关文章

MinMaxScaler中的scale_属性和min_属性

class sklearn preprocessing MinMaxScaler feature range 0 1 copy True 首先可以使用数据归一化 scaler MinMaxScaler feature range 0 1
[激光原理与应用-43]：《光电检测技术-10》- 激光测距原理、方案与案例分析：TOF VL53L0X模块

目录第1章激光测距概述 1 1 什么是激光测距 1 2 激光测距的特点 1 3 激光测距仪的形态 1 4 测距的类型 1 5 常见品牌 1 6 应用第2章测量原理 2 1 测量方法 2 2 测量方法分类第3章案例分析1 科扬光电
Javascript 与 ActionScript 中 null、NaN和undefined的区别

AS中其实Null NaN和undefined都是变量的默认初始值变量类型不同系统给与的初始值就不同 int uint 0Boolean falseNumber NaNString Array Object null未指定变量类型 u
合宙Air105

基于Air105开发板 Air105 LuatOS 文档上手开发上手 LuatOS 文档前文合宙Air105 摄像头 capture SPI Serial 串口 TFTLCD Micro SD卡 GC032A USB转TTL 官方d
Go操作supervisor xml rpc接口及注意事项

Go操作supervisor xml rpc接口及注意事项文章目录 Go操作supervisor xml rpc接口及注意事项 1 前言 2 管理web 3 go处理库 4 实时日志处理代码片段 1 前言之前提到过目前我们的进程都是通过
【python脚本】通过adb控制android手机

使用adb连接手机 1 下载adb zip工具包自行百度 2 解压后的文件夹中有adb exe fastboot exe和两个dll扩展程序文件 3 打开cmd 进入到当前文件夹中输入命令 adb devices 查看当前与电脑连接的
使用jpa插入数据报错“could not execute statement； SQL [n/a]；nested exception.DataException

前言在写开始采集接口用swagger测试时报了一个这样的错使用jpa插入数据报错 could not execute statement SQL n a nested exception DataException 这个错误网上找了
2020年研究生数学建模竞赛总结复盘

文章目录一前言二赛题选择三做题思路问题一数据清洗问题二数据降维问题三建模预测问题四分析模型预测结果与实际值问题五可视化四总结五结果三等奖一前言今天是2020年研究生数学建模竞赛的最后一天今早
git deamon 一个简单的git服务器

git deamon 一个简单的git服务器一 Git daemon 二操作三参考四总结一 Git daemon Git daemon是一个简单的git仓库服务器可以用来共享局域网的本地仓库二操作以下示例A电脑共享gi
使用BindingList实现DataGridView的动态绑定

在DataGridView数据绑定时使用BindingSource中转可以起到很好的控制DataGridView
指针基础（2）【数组与指针】

文章目录写在前面 1 数组概述 1 1 一维数组 1 2 二维数组 1 3 多维数组 1 4 小结 2 C 中 vector 容器 2 1 定义和初始化 vector 对象 2 2 向 vector 对象中增加元素 2 3 vector
MQTT异常断开

MQTT异常断开讨论一下TCP链路的影响 MQTT异常断开 TCP链路原因的几种情况三种情况 1 客户端发送了心跳请求但是MQTT代理服务器Broker没有收到心跳请求所以也不会回复客户端心跳响应 MQTT代理服务器Broker在
前端 115道面试题总结【持续更新...】

前端面试题 1 说说你对useEffect的理解可以模拟哪些生命周期 2 说说Real DOM和Virtual DOM的区别优缺点 3 说说React中setState和replaceState的区别 4 说说React生命周期有哪些不
Web 开发中 20 个很有用的 CSS 库

http www oschina net translate css libraries for developers
Android 开机加速优化

文章目录 Android 开机加速优化关闭BootLoader的企鹅关闭开机动画Android 关闭锁屏删除预装APP 查看预装APP 删除编译生成的APK 不编译APK 1 统一配置 2 修改单个APK的Android mk 谷歌A
2022年5月计划（UE4视频教程+osgearth源码调试+ogreRenderSystem源码抄写）

按照年度计划走就可以了五一期间突击完了ue4第七套视频教程客户端差不多了各项终于达到什么都会什么都不精了没有短板也没有长处平衡进行就行了包括久违的渲染也可以引进了以前如果单单干渲染是不行的毕竟这种工作少还要会引擎架构
springboot集成dubbo(详细配置)

前言首先要搭建zookeeper环境并启动可参照window下搭建zookeeper 半生归来仍少年的博客 CSDN博客 dubbo管理平台搭建下载 dubbo admin 2 5 8 war 互联网文档类资源 CSDN下载放到to
编译 java_如何编译java

展开全部用命令32313133353236313431303231363533e58685e5aeb931333337613139提示符编译java程序的步骤 1 先新建文本文档输入自己的java程序这里我写一个简单的java程序来
计算机网络arp表作用,arp映射表是什么？有什么作用

在如今每一天的生活中大家都需要有网络的陪伴相比于手机的4G流量和无线网卡大家更钟爱于wifi 因为它能够更加方便的使用可是在我们刚刚购买或者安装路由器的时候也会遇到很多的难题比如说什么是arp arp映射表有什么作用接下来就让我们

随机推荐

关于医学影像中的轴位面（横断面）、冠状面、矢状面

冠状位矢状位轴位图解第1页概述该页主题为冠状位矢状位轴位图解的图片集内容包含有冠状位矢状位横断位具体怎么辨别谢谢 ct 解剖颞骨大体解剖轴位及冠状位ct断层图像解剖颞骨大体解剖轴位及冠状位ct断层图像图1 a 矢状
vue制作幻灯片时涉及的transition动画(动图)

幻灯片使用频率很高就是各个网站的轮播大图为了使图片更加平滑的过渡就考虑给幻灯片加上transition动画先看实现的效果然后再分析动画原理上图可以看出幻灯片是慢慢的滑出来而不是一下一下的跳出来 1 transition动画原
前端面试--大众点评

学习了这么久第一次面试前端虽然只是电话面试但是还是很紧张主要问题 1 介绍你的项目 2 html的状态 3html5新增加的标签 4 css的display none和visibility区别 5 怎么清除浮动 6 jquery的选
【TensorFlow 入门】7、定义图变量的方法

1 tf Variable tf Variable init initial value trainable True collections None validate shape True name None 参数名称参数类型参数含
DNS服务器列表

Public DNS IPv4 地址首选 119 29 29 29 AliDNS 阿里公共 DNS IPv4 地址首选 223 5 5 5 备用 223 6 6 6 114 DNS 常规公共 DNS 干净无劫持首选 114 114 1
SpringCloud---Sentinel

文章目录限流 sentinel使用环境搭建设置限流默认直接模式关联模式链路模式关闭URL PATH聚合熔断降级设置模拟环境满调用比例规则 Sentinel 异常处理模式异常处理自定义异常处理热点测试热点环境搭建
用mysqldump备份及结合binlog日志恢复的全过程

1 查看更新备份时的数据 mysql gt select from t1 id 1 2 3 2 因为我的存储引擎是Myisam 为了保证数据的一直我加了参数 l 备份时不能对数据更新如果是innodb引擎加参数 single transc
Speed up calculation by running in parallel

原文链接 https perlmaven com speed up calculation by running in parallel In this example we have a bunch of numbers We need
Inception V1 V2 V3 V4

最开始卷积的层数不断增加后来开始修改卷积核的形式一二Inception V1 同一层级进行多尺度卷积扩展了宽度同时加强对小目标的检测能力 A 引入1 1的卷积是为了降维降低通道维度 B 在中间层加入辅助损失辅助损失只用于训练
fastCGI的安装和使用

一安装 1 先安装2个包 spawn fcgi 1 6 4 tar gz fcgi 2 4 1 SNAP 0910052249 安装 fcgi 2 4 1 SNAP 0910052249 报错 fcgio cpp In destructo
Git合并不同url的项目

本文由云社区发表作者工程师小熊摘要为了让项目能实现Git Gerrit Jenkin的持续集成我们把项目从Git上迁移到了Gerrit上发现有的同事在老Git提交代码因为Gerrit做了同步在Gerrit上有新提交的时候就
json文件格式详解

json文件格式详解 JSON JavaScript Object Notation 是一种轻量级的数据交换格式易于人阅读和编写同时也易于机器解析和生成它基于JavaScript Programming Language Standa
Latex排列图片：自由定义N行M列的排列方式

首先导包 usepackage graphicx usepackage float usepackage subfigure 图片排成一行 begin figure htbp centering subfigure 图1 begin min
【解决weditor报错】Local server not started, start with

前言大家在使用weditor查找元素的时候经常会遇到 Local server not started start with 这个错误下面是我个人的一些解决方法供大家参考原因1 浏览器问题导致浏览器的原因导致的界面未刷新我的就
解决从GitHub下载文件时缓慢的问题

我们知道访问GitHub在国内的速度还算过得去但是从GitHub上下载文件的速度就非常慢了以下方法就是为了解决下载速度缓慢的截止2019 9 5前测试有效 1 用记事本打开hosts文件路径为C Windows System32
Mysql 实践（一）：部署和安装

1 目标卸载centos自带的mysql 安装mysql 5 6 33 2 步骤 1 下载mysql 下载地址 http dev mysql com downloads mysql 5 6 html downloads 我们下载这些包
基于SSM框架的实验室开放管理系统

系统功能结构设计在分析并得出使用者对程序的功能要求时就可以进行程序设计了管理员功能结构图管理员主要负责填充图书和其类别信息并对已填充的数据进行维护包括修改与删除管理员也需要审核老师注册信息发布公告信息管理自助租房信息等用
flutter初学之悬浮按钮

期望想实现一个悬浮在整个页面的悬浮按钮实现1 用FloatingActionButton实现新增悬浮按钮 Widget createFixedAddWidget ProductEntryState state Dispatch dis
linux环境下查看因内存占用过大被杀掉的进程

文章目录前言查询方法通过系统日志查找通过dmesg命令查找进程被杀的原因总结前言最近发生两次游戏服务器进程突然消失的事件查询日志上下文没有找到有用的信息日志显示运行到某处戛然而止此处代码逻辑简单排除异常逻辑导致的服务
data_support/utlist（关于编译器的一些宏宏设置）

ifndef UTLIST H tlist 权限查看程序 define UTLIST H define UTLIST VERSION 1 9 8 include

data_support/utlist（关于编译器的一些宏宏设置）

data_support/utlist（关于编译器的一些宏宏设置） 的相关文章

随机推荐

热门标签

data_support/utlist（关于编译器的一些宏宏设置）的相关文章