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

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

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

## RWTPtrMap<K,T,C>

### 形式

      #include <rw/tpmap.h>
      RWTPtrMap<K,T,C> m;

### 標準 C++ ライブラリ依存

  > 注 - RWTPtrMap には標準 C++ ライブラリが必要です。

### 説明

  このクラスは、型 `pair<K* const, T*>` の関連付けの、ポインタにもとづくコレクションを維持します。関連付けの最初の部分は型 `K*` のキーで、2 番目はそれに関連する型 `T*` の項目です。順序は、型 `C` の比較オブジェクトに従って、キーによって決定されます。`C` は、次の公開メンバーを介して、型 `K` の要素に対する全順序付けを誘導しなければなりません。

        bool operator()(const K& x, const K& y)

  これは、コレクション内において、`x` とそのパートナーが `y` とそのパートナーより前になる場合、`TRUE` を返します。C++ 標準ヘッダーファイル `<functional>` からの構造体 `less<T>` がその例です。キーは比較前に間接参照されることに注意してください。

  RWTPtrMap<K,T,C> は、コレクション内の既存のキーと等しいキーは受け付けません (RWTPtrMultiMap<K,T,C> には、互いに等しい複数のキーを含めることができます)。等しいかどうかは、`==` 演算子ではなく、比較オブジェクトにもとづいて判定されます。比較オブジェクト `comp` を使用するとき、キー `a` と `b` は次の場合に等しくなります。

        !comp(a,b) && !comp(b,a)

### 持続性

  同形

### 例

  この例では、RWCString と RWDate のマップを使用しています。

      //
      // tpmap.cpp
      //
      #include <rw/tpmap.h>
      #include <rw/cstring.h>
      #include <rw/rwdate.h>
      #include <iostream.h>
      #include <function.h>

      main(){
        RWTPtrMap<RWCString, RWDate, less<RWCString> > birthdays;

        birthdays.insert
         (
           new RWCString("John"),
           new RWDate(12, "April", 1975)
         );
        birthdays.insert
         (
           new RWCString("Ivan"),
           new RWDate(2, "Nov", 1980)
         );

        // 別の構文：
        birthdays[new RWCString("Susan")] =
          new RWDate(30, "June", 1955);
        birthdays[new RWCString("Gene")] =
          new RWDate(5, "Jan", 1981);

        // 誕生日を出力：
        RWCString key("John");
        cout << *birthdays[&key] << endl;
        return 0;
      }

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

      04/12/75

### 関連クラス

  クラス RWTPtrMultiMap<K,T,C> は、互いに等しい複数のキーを受け付けるポインタにもとづくコレクションに対して同じインタフェースを提供します。RWTPtrSet<T,C> は、関連付けられた項目のないキーのポインタにもとづくコレクションを維持します。

  クラス map<K*,T*,deref_compare<C,K,allocator>> は、このコレクションの基礎となる実装として使用される C++ 標準コレクションです。

### 公開 Typedef

      typedef rw_deref_compare<C,K>                  container_comp;
      typedef map<K*,T*,container_comp, 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 pair <K* const, T*>                    value_type;
      typedef pair <K* const, T*>&                   reference;
      typedef const pair <K* const, T*>&             const_reference;
      typedef K*                                     value_type_key;
      typedef T*                                     value_type_data;
      typedef K*&                                    reference_key;
      typedef T*&                                    reference_data;
      typedef const K*const&                   const_reference_key;
      typedef const T*const&                   const_reference_data;

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

      RWTPtrMap<K,T,C>
      (const container_comp& comp = container_comp());

    比較関数 `comp` を使って空のマップを作成します。

      RWTPtrMap<K,T,C>(const RWTPtrMap<K,T,C>& rwm);

    コピーコンストラクタ。

      RWTPtrMap<K,T,C>(const container_type& m);

    `m` からすべての要素をコピーすることによって、マップを作成します。

      RWTPtrMap<K,T,C>
      (value_type* first,value_type* last,
       const container_comp& comp = container_comp());

    `first` が指す `pair` の配列から `last` が指すペアまで (ただし、そのペアは含みません)、要素をコピーすることによって、マップを作成します。

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

      RWTPtrMap<K,T,C>&
      operator=(const RWTPtrMap<K,T,C>& m);
      RWTPtrMap<K,T,C>&
      operator=(const container_type& m);

    自分自身のすべての関連付けを削除し、`m` からすべての関連付けをコピーすることによって、それらを置き換えます。

      bool
      operator<(const RWTPtrMap<K,T,C>& m) const;

    自分自身が辞書形式で `m` より小さい場合は `TRUE` を返し、等しいか大きい場合は `FALSE` を返します。各コレクションのキーは比較前に間接参照されます。型 `K` に明確に規定された `less-than` 意味論があると仮定します。

      bool
      operator==(const RWTPtrMap<K,T,C>& m) const;

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

      T*&
      operator[](const K* key);

    `key` を検索し、関連付けられた項目への参照を返します。辞書にキーがない場合、型 `T*` の未初期化ポインタがキーに関連付けられて、追加されます。このため、キーが辞書にない可能性がある場合には、この演算子は左辺値としてのみ使用しなければなりません。

### 公開メンバー関数

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

    `fn` が指すユーザー定義関数を、コレクション内の各関連付けに適用します。この関数は、次のプロトタイプの 1 つを持っていなければなりません。

          void yourfun(const K* key, T*& a, void* d);
          void yourfun(const K* key, const T* a, void* d);

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

      void
      applyToKeyAndValue(void (*fn)(const K*,T*&,void*),void* d);
      void
      applyToKeyAndValue
      (void (*fn)(const K*,const T*,void*),void* d) const;

    これは、上記 `apply` メンバーの陳腐化した (古くなった) バージョンです。機能は `apply` とまったく同じです。

      iterator
      begin();

      const_iterator
      begin() const;

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

      void
      clear();

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

      void
      clearAndDestroy();

    コレクションからすべての関連付けを削除し、`delete` 演算子を使用して、キーとそれらの関連付けられた項目が指すオブジェクトを破棄します。同じオブジェクトに対して複数のポインタが格納される場合は、このメソッドを使用しないでください (比較中には項目は考慮されないため、キーがすべて異なる場合も同様です)。

      bool
      contains(const K* key) const;

    自分自身内に `*key` と等しいキー `j` が存在する場合は、`TRUE` を返します。それ以外の場合は、`FALSE` を返します。

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

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

         bool yourTester(value_type a, void* d);

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

      iterator
      end();

      const_iterator
      end() const;

    自分自身内の最後の関連付けの「直後」にある反復子を返します。

      size_type
      entries() const;

    自分自身内の関連付けの数を返します。

      const K*
      find(const K* key) const;

    自分自身内に `*key` と等しいキー `j` が存在する場合は、`j` を返します。それ以外の場合は、`rwnil` を返します。

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

    自分自身内に式 `((*fn)(a,d))` が `TRUE` になるような関連付け `a` が存在する場合は、`a` を返します。それ以外の場合は、`pair<rwnil,rwnil>` を返します。`fn` が指すユーザー定義テスター関数は、次のプロトタイプを持っていなければなりません。

         bool yourTester(value_type a, void* d);

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

      T*
      findValue(const K* key);

      const T*
      findValue(const K* key) const;

    自分自身内に `*key` と等しいキー `j` が存在する場合は、`j` に関連付けられている項目を返します。それ以外の場合は、`rwnil` を返します。

      const K*
      findKeyAndValue(const K* key, T*& tr);
      const K*
      findKeyAndValue(const K* key, const T*& tr) const;

    自分自身内に `*key` と等しいキー `j` が存在する場合は、`j` を `kr` に代入し、`j` に関連付けられている項目を `tr` に代入し、`j` を返します。それ以外の場合は、`rwnil`を返し、`tr` の値は変更しません。

      bool
      insert(K* key, T* a);

    項目 `a` が関連付けられている `key` をコレクションに追加します。挿入が正常に行われた場合は `TRUE` を返し、それ以外の場合は `FALSE` を返します。コレクションが同値キーとの関連付けを持たない限り、この関数は `TRUE` を返します。

      bool
      insertKeyAndValue(K* key, T* a);

    これは、上記 `insert` メンバーの陳腐化した (古くなった) バージョンです。機能は `insert` とまったく同じです。

      bool
      isEmpty() const;

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

      size_type
      occurrencesOf(const K* key) const;

    `*key` と等しい自分自身内のキー `j` の数を返します。

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

    式 `((*fn)(a,d))` が `TRUE` になるような自分自身内の関連付け `a` の数を返します。`fn` が指すユーザー定義テスター関数は、次のプロトタイプを持っていなければなりません。

             bool yourTester(value_type a, void* d);

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

      K*
      remove(const K* key);

    `*key` と等しい自分自身内のキー `j` との最初の関連付けを削除し、`j` を返します。そのような関連付けが存在しない場合は、`rwnil` を返します。

      K*
      remove(bool (*fn)(value_type,void*), void* d);

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

         bool yourTester(value_type a, void* d);

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

      size_type
      removeAll(const K* key);

    `*key` と等しい自分自身内のキー `j` との関連付けをすべて削除します。削除した関連付けの数を返します。

      size_type
      removeAll(bool (*fn)(value_type,void*), void* d);

    式 `((*fn)(a,d))` が `TRUE` になるような自分自身内のすべての関連付け `a` を削除します。削除した数を返します。`fn` が指すユーザー定義テスター関数は、次のプロトタイプを持っていなければなりません。

         bool yourTester(value_type a, void* d);

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

      container_type
      std();
      const container_type
      std() const;

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

### 関連の大域演算子

      RWvostream&
      operator<<(RWvostream& strm, const RWTPtrMap<K,T,C>& coll);
      RWFile&
      operator<<(RWFile& strm, const RWTPtrMap<K,T,C>& coll);

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

      RWvistream&
      operator>>(RWvistream& strm, RWTPtrMap<K,T,C>& coll);
      RWFile&
      operator>>(RWFile& strm, RWTPtrMap<K,T,C>& coll);

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

      RWvistream&
      operator>>(RWvistream& strm, RWTPtrMap<K,T,C>*& p);
      RWFile&
      operator>>(RWFile& strm, RWTPtrMap<K,T,C>*& p);

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