GCC Wikia
Advertisement

目次

  1. contents

このページを編集する際は,編集に関する方針に従ってください.[]

概要[]

引数[]

  • T

実装[]

498 #define DEF_VEC_FUNC_P(T)                                                 \

&aname(length);
== *length  ==

*VECのnumメンバを返す

499 static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_)   \
500 {                                                                         \
501   return vec_ ? vec_->num : 0;                                            \
502 }                                                                         \
503                                                                           \

&aname(last);
== *last  ==

*VECのデータの数はnum個のようなので、これでvec配列の最後の値が返る

504 static inline T VEC_OP (T,base,last)                                      \
505      (const VEC(T,base) *vec_ VEC_CHECK_DECL)                             \
506 {                                                                         \
507   VEC_ASSERT (vec_ && vec_->num, "last", T, base);                        \
508                                                                           \
509   return vec_->vec[vec_->num - 1];                                        \
510 }                                                                         \
511                                                                           \

&aname(index);
== *index  ==

*ix_で指定された値を返す

512 static inline T VEC_OP (T,base,index)                                     \
513      (const VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL)               \
514 {                                                                         \
515   VEC_ASSERT (vec_ && ix_ < vec_->num, "index", T, base);                 \
516                                                                           \
517   return vec_->vec[ix_];                                                  \
518 }                                                                         \
519                                                                           \

&aname(iterate);
== *iterate  ==

*indexはVEC_ASSERTで範囲外ならばエラーにするが、こちらは範囲外の場合0を返す

520 static inline int VEC_OP (T,base,iterate)                                 \
521      (const VEC(T,base) *vec_, unsigned ix_, T *ptr)                      \
522 {                                                                         \
523   if (vec_ && ix_ < vec_->num)                                            \
524     {                                                                     \
525       *ptr = vec_->vec[ix_];                                              \
526       return 1;                                                           \
527     }                                                                     \
528   else                                                                    \
529     {                                                                     \
530       *ptr = 0;                                                           \
531       return 0;                                                           \
532     }                                                                     \
533 }                                                                         \
534                                                                           \

&aname(embedded_size);
== *embedded_size  ==

*全体の大きさを返す
**vecまでの大きさ + vecに割り当てた領域の大きさ

535 static inline size_t VEC_OP (T,base,embedded_size)                        \
536      (int alloc_)                                                         \
537 {                                                                         \
538   return offsetof (VEC(T,base),vec) + alloc_ * sizeof(T);                 \
539 }                                                                         \
540                                                                           \
== *embedded_init  ==

*vec_の初期化

541 static inline void VEC_OP (T,base,embedded_init)                          \
542      (VEC(T,base) *vec_, int alloc_)                                      \
543 {                                                                         \
544   vec_->num = 0;                                                          \
545   vec_->alloc = alloc_;                                                   \
546 }                                                                         \
547                                                                           \
== *space  ==

*vec_の中にalloc_分の領域が余っているか

548 static inline int VEC_OP (T,base,space)                                   \
549      (VEC(T,base) *vec_, int alloc_ VEC_CHECK_DECL)                       \
550 {                                                                         \
551   VEC_ASSERT (alloc_ >= 0, "space", T, base);                             \
552   return vec_ ? vec_->alloc - vec_->num >= (unsigned)alloc_ : !alloc_;    \
553 }                                                                         \
554                                                                           \
== *quick_push  ==

*obj_をvec_に挿入し、obj_が挿入されたアドレスを返す

555 static inline T *VEC_OP (T,base,quick_push)                               \
556      (VEC(T,base) *vec_, T obj_ VEC_CHECK_DECL)                           \
557 {                                                                         \
558   T *slot_;                                                               \
559                                                                           \
560   VEC_ASSERT (vec_->num < vec_->alloc, "push", T, base);                  \
561   slot_ = &vec_->vec[vec_->num++];                                        \
562   *slot_ = obj_;                                                          \
563                                                                           \
564   return slot_;                                                           \
565 }                                                                         \
566                                                                           \
== *pop  ==

*vec_に入っている(最後尾の)データを取り出す

567 static inline T VEC_OP (T,base,pop) (VEC(T,base) *vec_ VEC_CHECK_DECL)    \
568 {                                                                         \
569   T obj_;                                                                 \
570                                                                           \
571   VEC_ASSERT (vec_->num, "pop", T, base);                                 \
572   obj_ = vec_->vec[--vec_->num];                                          \
573                                                                           \
574   return obj_;                                                            \
575 }                                                                         \
576                                                                           \
== *truncate  ==

*size_分データが入っていることにする

577 static inline void VEC_OP (T,base,truncate)                               \
578      (VEC(T,base) *vec_, unsigned size_ VEC_CHECK_DECL)                   \
579 {                                                                         \
580   VEC_ASSERT (vec_ ? vec_->num >= size_ : !size_, "truncate", T, base);   \
581   if (vec_)                                                               \
582     vec_->num = size_;                                                    \
583 }                                                                         \
584                                                                           \
== *replace  ==

*ix_番目のデータを置き換え、古いデータを返す

585 static inline T VEC_OP (T,base,replace)                                   \
586      (VEC(T,base) *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL)             \
587 {                                                                         \
588   T old_obj_;                                                             \
589                                                                           \
590   VEC_ASSERT (ix_ < vec_->num, "replace", T, base);                       \
591   old_obj_ = vec_->vec[ix_];                                              \
592   vec_->vec[ix_] = obj_;                                                  \
593                                                                           \
594   return old_obj_;                                                        \
595 }                                                                         \
596                                                                           \
== *quick_insert  ==

*データの挿入

597 static inline T *VEC_OP (T,base,quick_insert)                             \
598      (VEC(T,base) *vec_, unsigned ix_, T obj_ VEC_CHECK_DECL)             \
599 {                                                                         \
600   T *slot_;                                                               \
601                                                                           \

*エラーチェック

602   VEC_ASSERT (vec_->num < vec_->alloc, "insert", T, base);                \
603   VEC_ASSERT (ix_ <= vec_->num, "insert", T, base);                       \

*挿入する場所のアドレスを取得

604   slot_ = &vec_->vec[ix_];                                                \

*挿入する場所から後ろのデータは一つずらす

605   memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T));           \
606   *slot_ = obj_;                                                          \
607                                                                           \
608   return slot_;                                                           \
609 }                                                                         \
610                                                                           \
== *ordered_remove  ==

*データの削除

611 static inline T VEC_OP (T,base,ordered_remove)                            \
612      (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL)                     \
613 {                                                                         \
614   T *slot_;                                                               \
615   T obj_;                                                                 \
616                                                                           \
617   VEC_ASSERT (ix_ < vec_->num, "remove", T, base);                        \
618   slot_ = &vec_->vec[ix_];                                                \
619   obj_ = *slot_;                                                          \

*一つづらして上書き

620   memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T));           \
621                                                                           \
622   return obj_;                                                            \
623 }                                                                         \
624                                                                           \
== *unordered_remove  ==

*データの削除 
**一番後ろのデータで上書きする

625 static inline T VEC_OP (T,base,unordered_remove)                          \
626      (VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL)                     \
627 {                                                                         \
628   T *slot_;                                                               \
629   T obj_;                                                                 \
630                                                                           \
631   VEC_ASSERT (ix_ < vec_->num, "remove", T, base);                        \
632   slot_ = &vec_->vec[ix_];                                                \
633   obj_ = *slot_;                                                          \
634   *slot_ = vec_->vec[--vec_->num];                                        \
635                                                                           \
636   return obj_;                                                            \
637 }                                                                         \
638                                                                           \
== *address  ==

*vecメンバが指しているアドレスを返す

639 static inline T *VEC_OP (T,base,address)                                  \
640      (VEC(T,base) *vec_)                                                  \
641 {                                                                         \
642   return vec_ ? vec_->vec : 0;                                            \
643 }                                                                         \
644                                                                           \
== *lower_bound  ==

*二分探索

645 static inline unsigned VEC_OP (T,base,lower_bound)                        \
646      (VEC(T,base) *vec_, const T obj_,                                    \
647       bool (*lessthan_)(const T, const T) VEC_CHECK_DECL)                 \
648 {                                                                         \
649    unsigned int len_ = VEC_OP (T,base, length) (vec_);                    \
650    unsigned int half_, middle_;                                           \
651    unsigned int first_ = 0;                                               \
652    while (len_ > 0)                                                       \
653      {                                                                    \
654         T middle_elem_;                                                   \
655         half_ = len_ >> 1;                                                \
656         middle_ = first_;                                                 \
657         middle_ += half_;                                                 \
658         middle_elem_ = VEC_OP (T,base,index) (vec_, middle_ VEC_CHECK_PASS); \
659         if (lessthan_ (middle_elem_, obj_))                               \
660           {                                                               \
661              first_ = middle_;                                            \
662              ++first_;                                                    \
663              len_ = len_ - half_ - 1;                                     \
664           }                                                               \
665         else                                                              \
666           len_ = half_;                                                   \
667      }                                                                    \
668    return first_;                                                         \
669 }


リンク元

Advertisement