Tools.h++ 7.0 クラスライブラリ・リファレンスマニュアル: RWTPtrDlist

バナーをクリックすれば目次に戻ります

Copyright 1999 Rogue Wave Software
Copyright 1999 Sun Microsystems, Inc.

## RWTPtrDlist<T>

### 形式

      #include <rw/tpdlist.h>
      RWTPtrDlist<T> dlist;

  > 注 - 標準 C++ ライブラリがある場合は、ここで述べるインタフェースを使用します。標準 C++ ライブラリがない場合は、付録 A に記載する RWTPtrDlistIterator への制限付きインタフェースを使用してください。

### 説明

  このクラスは、型 `T` へのポインタのコレクションを保守するもので、二重リンクリストとして実装されます。

### 持続性

  同形

### 例

  次の例は、ユーザー型 `Dog` へのポインタの二重リンクリストを処理しています。

      //
      // tpdlist.cpp
      //
      #include <rw/tpdlist.h>
      #include <iostream.h>
      #include <string.h>

      class Dog {
        char* name;
      public:
        Dog( const char* c) {
         name = new char[strlen(c)+1];
         strcpy(name, c); }

        ~Dog() { delete name; }

        // コピーコンストラクタを定義する
        Dog(const Dog& dog) {
         name = new char[strlen(dog.name)+1];
         strcpy(name, dog.name); }

        // 代入演算子を定義する
        void operator=(const Dog& dog) {
         if (this!=&dog) {
           delete name;
           name = new char[strlen(dog.name)+1];
           strcpy(name, dog.name);
        }
        }
        // 等価テスト演算子を定義する
        int operator==(const Dog& dog) const {
        return strcmp(name, dog.name)==0; }
        // 名前によるアルファベット順序付け
        int operator<(const Dog& dog) const {
        return strcmp(name, dog.name)<0; }
        friend ostream& operator<<(ostream& str, const Dog& dog){
          str << dog.name;
          return str;}
      };

      main(){
        RWTPtrDlist<Dog> terriers;
        terriers.insert(new Dog("Cairn Terrier"));
        terriers.insert(new Dog("Irish Terrier"));
        terriers.insert(new Dog("Schnauzer"));

        Dog key1("Schnauzer");
        cout << "The list " <<
          (terriers.contains(&key1) ? "does " : "does not ") <<
          "contain a Schnauzer\n";

        Dog key2("Irish Terrier");
        terriers.insertAt(
            terriers.index(&key2),
            new Dog("Fox Terrier")
          );

        Dog* d;
        while (!terriers.isEmpty()) {
          d = terriers.get();
          cout << *d << endl;
          delete d;
        }

        return 0;
      }

  #### プログラム出力:

      The list does contain a Schnauzer
      Cairn Terrier
      Fox Terrier
      Irish Terrier
      Schnauzer

### 関連クラス

  クラス RWTPtrDeque<T>、RWTPtrSlist<T>、および RWTPtrOrderedVector<T> も、C++ 標準シーケンスコレクションとの、Rogue Wave のポインタベースのインタフェースを提供します。

  クラス list<T*, allocator> は、このクラスの実装として利用される C++ 標準コレクションです。

### 公開 Typedefs

      typedef list<T*, allocator>                    container_type;
      typedef container_type::size_type              size_type;
      typedef container_type::difference_type        difference_type;
      typedef container_type::iterator               iterator;
      typedef container_type::const_iterator         const_iterator;
      typedef T*                                     value_type;
      typedef
      typedef T*                                     reference;
      typedef T* const&                              const_reference;

### 公開コンストラクタ

      RWTPtrDlist<T>();

    空の二重リンクリストを作成します。

      RWTPtrDlist<T>(const RWTPtrDlist<T>& rwlst);

    コピーコンストラクタ。

      RWTPtrDlist<T>(const list<T*, allocator>& lst);

    `lst` のすべての要素をコピーすることによりポインタベースの二重リンクリストを作成します。

      RWTPtrDlist<T>(size_type n, T* a=0);

    それぞれが `a` に初期化された `n` 個の要素を持つ二重リンクリストを作成します。

      RWTPtrDlist<T>(T*const* first, T*const* last);

    要素をコピーすることにより二重リンクリストを作成します。要素は、`first` から `last` までが指す `T*` の配列からコピーされますが、`last` が指す要素は含まれません。

### 公開メンバー演算子

      RWTPtrDlist<T>&
      operator=(const list<T*, allocator>& lst);
      RWTPtrDlist<T>&
      operator=(const RWTPtrDlist<T>& lst);

    自分自身のすべての要素をクリアし、`lst` のすべての要素をコピーすることによって、それらを置き換えます。

      bool
      operator<(const RWTPtrDlist<T>& lst);

    自分自身が辞書形式で `lst` より小さい場合は `TRUE` を返し、それ以外の場合は `FALSE` を返します。各コレクションの項目は比較前に間接参照されます。型 `T` には明確に定義された less-than 意味論があると仮定します。

      bool
      operator==(const RWTPtrDlist<T>& lst);

    自分自身が `lst` と等しい場合は `TRUE` を返し、それ以外の場合は `FALSE` を返します。2 つのコレクションのエントリ数が同じで、両方のコレクションを反復したときに個々の要素が互いに等しい場合、両者は等しいと言えます。要素は比較前に間接参照されます。

      reference
      operator()(size_type i);
      const_reference
      operator()(size_type i) const;

    自分自身の `i` 番目の要素への参照を返します。インデックス `i` は、`0` 〜 (エントリ数 -1) の範囲内でなければなりません。それ以外の場合の結果は定義されていません。境界検査は実行されません。

      reference
      operator[](size_type i);
      const_reference
      operator[](size_type i) const;

    自分自身の `i` 番目の要素への参照を返します。インデックス `i` は、`0` 〜 (自分自身内のエントリ数 -1) の範囲内でなければなりません。それ以外の場合、この関数は、型 RWBoundsErr の例外を送出します。

### 公開メンバー関数

      void
      append(T* a);

    コレクションの最後に項目 `a` を追加します。

      void
      apply(void (*fn)(T*,void*), void* d);
      void
      apply(void (*fn)(T*&,void*), void* d);
      void
      apply(void (*fn)(const T*,void*), void* d) const;

    `fn` が指すユーザー定義関数を、コレクション内の各項目に適用します。この関数は、参照意味論のために、次のどちらかのプロトタイプを持っていなければなりません。

         void yourfun(T* a, void* d);
         void yourfun(const T* a, void* d);
         void yourfun(reference a, void* d);

    クライアントデータは、パラメータ `d` を通して渡すことができます。

      const
      const_reference
      at (size_type i);
      reference
      at(size_type i);

    自分自身の `i` 番目の要素への参照を返します。インデックス `i` は、`0` 〜 (自分自身のエントリ数 -1) の範囲内でなければなりません。それ以外の場合、この関数は、型 RWBoundsErr の例外を送出します。

      iterator
      begin();
      const_iterator
      begin() const;

    自分自身の最初の要素の位置にある反復子を返します。

      void
      clear();

    自分自身から項目をすべて削除することによって、コレクションを消去します。

      void
      clearAndDestroy();

    コレクションからすべての項目を削除し、`delete` 演算子を使用して、これらの項目が指すオブジェクトを破棄します。同じオブジェクトに対して複数のポインタが格納される場合は、このメソッドを使用しないでください。

      bool
      contains(const T* a) const;

    自分自身内に式 (`*t == *a`) が `TRUE` になるような要素 `t` が存在する場合は、`TRUE` を返します。それ以外の場合は、`FALSE` を返します。

      bool
      contains(bool (*fn)(T*,void*), void* d) const;
      bool
      contains(bool (*fn)(const T*,void*), void* d) const;

    自分自身内に式 `((*fn)(t,d))` が `TRUE` になるような要素 t が存在する場合は、`TRUE` を返します。それ以外の場合は、`FALSE` を返します。`fn` が指すユーザー定義テスター関数は、次のプロトタイプの 1 つを `const` バージョン用に持っていなければなりません。

         bool yourTester(T* a, void* d);
         bool yourTester(const T* a, void* d);

    クライアントデータは、パラメータ `d` を通して渡すことができます。

      iterator
      end();
      const_iterator
      end() const;

    自分自身内の最後の要素の「直後」にある反復子を返します。

      size_type
      entries() const;

    自分自身内の項目数を返します。

      T*
      find(const T* a) const;

    自分自身内に式 `(*t == *a)` が `TRUE` になるような要素 `t` が存在する場合は、`t` を返します。それ以外の場合は、`rwnil` を返します。

      T*
      find(bool (*fn)(T*,void*), void* d) const;
      T*
      find(bool (*fn)(const T*,void*), void* d) const;

    自分自身内に式 `((*fn)(t,d))` が `TRUE` になるような要素 `t` が存在する場合は、`t` を返します。それ以外の場合は、`rwnil` を返します。`fn` が指すユーザー定義テスター関数は、次のプロトタイプの 1 つを `const` バージョン用に持っていなければなりません。

         bool yourTester(T* a, void* d);
         bool yourTester(const T* a, void* d);

    クライアントデータは、パラメータ `d` を通して渡すことができます。

      reference
      first();
      const_reference
      first() const;

    自分自身内の最初の要素への参照を返します。

      T*
      get();

    コレクション内の最初の要素を削除して返します。

      size_type
      index(const T* a) const;

    自分自身内に式 `(*t == *a)` が `TRUE` となるような項目 `t` が存在する場合は、その最初の位置を返します。そのような項目が存在しない場合は、静的メンバー `npos` を返します。

      size_type
      index(bool (*fn)(T*,void*), void* d) const;
      size_type
      index(bool (*fn)(const T*,void*), void* d) const;

    自分自身内に `((*fn)(t,d))` が `TRUE` になるような項目 `t` が存在する場合は、その最初の位置を返します。そのような項目が存在しない場合は、静的メンバー `npos` を返します。`fn` が指すユーザー定義テスター関数は、次のプロトタイプの 1 つを `const` バージョン用に持っていなければなりません。

         bool yourTester(T* a, void* d);
         bool yourTester(const T* a, void* d);

    クライアントデータは、パラメータ `d` を通して渡すことができます。

      bool
      insert(T* a);

    コレクションの最後に項目 `a` を追加します。`TRUE` を返します。

      void
      insertAt(size_type i, T* a);

    自分自身内の位置 i にある項目の前に項目 `a` を挿入します。この位置は `0` 〜 (コレクション内のエントリ数) の範囲内でなければなりません。それ以外の場合、この関数は、型 RWBoundsErr の例外を送出します。

      bool
      isEmpty() const;

    コレクション内に項目が存在しない場合は、`TRUE` を返します。それ以外の場合は、`FALSE` を返します。

      T*&
      last();
      T*const&
      last() const;

    コレクションの最後の項目への参照を返します。

      reference
      maxElement();
      const_reference
      maxElement() const;
      reference
      minElement();
      const_reference
      minElement() const;

    自分自身内の最大要素または最小要素への参照を返します。

      size_type
      occurrencesOf(const T* a) const;

    式 `(*t == *a)` が `TRUE` になるような自分自身内の要素 `t` の数を返します。

      size_type
      occurrencesOf(bool (*fn)( T*,void*), void* d) const;
      size_type
      occurrencesOf(bool (*fn)(const T*,void*), void* d) const;

    式 `((*fn)(t,d))` が `TRUE` になるような自分自身内の要素 `t` の数を返します。`fn` が指すユーザー定義テスター関数は、次のプロトタイプの 1 つ (後者は `const` バージョン用) を持っていなければなりません。

         bool yourTester(T* a, void* d);
         bool yourTester(const T* a, void* d);

    クライアントデータは、パラメータ `d` を通して渡すことができます。

      void
      prepend(T* a);

    コレクションの最初に項目 `a` を追加します。

      T*
      remove(const T* a);

    式 `(*t == *a)` が `TRUE` になるような自分自身内の最初の要素 `t` を削除して返します。そのような要素が存在しない場合は、`rwnil` を返します。

      T*
      remove(bool (*fn)( T*,void*), void* d);
      T*
      remove(bool (*fn)(const T*,void*), void* d);

    式 `((*fn)(t,d))` が `TRUE` になるような自分自身内の最初の要素 `t` を削除して返します。そのような要素が存在しない場合は、`rwnil` を返します。`fn` が指すユーザー定義テスター関数は、次のプロトタイプの 1 つを持っていなければなりません。

         bool yourTester(T* a, void* d);
         bool yourTester(const T* a, void* d);

    クライアントデータは、パラメータ `d` を通して渡すことができます。

      size_type
      removeAll(const T* a);

    式 `(*t == *a)` が `TRUE` になるような自分自身内の要素 `t` をすべて削除します。削除した項目数を返します。

      size_type
      removeAll(bool (*fn)( T*,void*), void* d);
      size_type
      removeAll(bool (*fn)(const T*,void*), void* d);

    式 `((*fn)(t,d))` が `TRUE` になるような自分自身内の要素 `t` をすべて削除します。削除した項目数を返します。`fn` が指すユーザー定義テスター関数は、次のプロトタイプの 1 つ (後者は`const` バージョン用) を持っていなければなりません。

         bool yourTester(T* a, void* d);
         bool yourTester(const T* a, void* d);

    クライアントデータは、パラメータ `d` を通して渡すことができます。

      T*
      removeAt(size_type i);

    自分自身内の位置 `i` にある項目を削除して返します。この位置は `0` 〜 (コレクション内のエントリ数 -1) の範囲内でなければなりません。それ以外の場合、この関数は、型 RWBoundsErr の例外を送出します。

      T*
      removeFirst();

    コレクション内の最後の項目を削除して返します。

      T*
      removeLast();

    コレクション内の最初の項目を削除して返します。

      size_type
      replaceAll(const T* oldVal,T* newVal);

    式 `(*t == *oldVal)` が `TRUE` になるような自分自身内の要素 `t` をすべて、`newVal` に置き換えます。置換した項目数を返します。

      size_type
      replaceAll(bool (*fn)(T*, void*),void* d,T* newVal);
      size_type
      replaceAll(bool (*fn)(const T*, void*),void* d,T* newVal);

    式 `((*fn)(t,d))` が `TRUE` になるような自分自身内の要素 `t` をすべて、`newVal` に置き換えます。置換した項目数を返します。`fn` が指すユーザー定義テスター関数は、次のプロトタイプの 1 つを持っていなければなりません。

         bool yourTester(T* a, void* d);
         bool yourTester(const T* a, void* d);

    クライアントデータは、パラメータ `d` を通して渡すことができます。

      void
      sort();

    要素を比較するために、less-than 演算子を使用して、コレクションをソートします。要素は比較前に間接参照されます。

      list<T*, allocator>&
      std();
      const list<T*, allocator>&
      std() const;

    自分自身に対する実装として使用される、基礎となる C++ 標準コレクションへの参照を返します。

### 静的公開データメンバー

      const size_type  npos;

    これは、`index` などのメンバー関数によって無効な位置を示すために返される値です。この値は、`~(size_type)0` と同じです。

### 関連の大域演算子

      RWvostream&
      operator<<(RWvostream& strm, const RWTPtrDlist<T>& coll);
      RWFile&
      operator<<(RWFile& strm, const RWTPtrDlist<T>& coll);

    出力ストリーム `strm` にコレクション `coll` を保存するか、すでに保存されている場合は、そのコレクションに対する参照を保存します。

      RWvistream&
      operator>>(RWvistream& strm, RWTPtrDlist<T>& coll);
      RWFile&
      operator>>(RWFile& strm, RWTPtrDlist<T>& coll);

    コレクション `coll` の内容を入力ストリーム `strm` から復元します。

      RWvistream&
      operator>>(RWvistream& strm, RWTPtrDlist<T>*& p);
      RWFile&
      operator>>(RWFile& strm, RWTPtrDlist<T>*& p);

    入力ストリーム `strm` 上の次のオブジェクトを調べて、ヒープから新しいコレクションを作成してそれを指すように `p` を設定するか、または前に読み込んだインスタンスを指すように `p` を設定します。コレクションをヒープから作成した場合、ユーザーはそれを削除する責任があります。