---
name: "ptriter"
section: "3bobcat"
platform: "linux"
package: "libbobcat-dev"
version: "6.07.01-2"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/ptriter"
---

# ptriter(3bobcat)

Iterator returning pointer when dereferenced

## NAME

FBB::PtrIter - Iterator returning pointer when dereferenced

## SYNOPSIS

**#include \<bobcat/ptriter\>**\

## DESCRIPTION

The *PtrIter* class template implements an input iterator whose *operator\** returns the address of the element the iterator refers to. Consider a *std::unordered\_map\<std::string, DataType\>*. Its *begin* member returns an iterator whose *operator\** returns a *std::pair\<std::string,* *DataType\> (const) &*. This is usually what you want, but now assume we want to display the map’s content, sorted by its keys. Sorting can simply be performed by defining a support vector containing pointers to the elements in the map, and then sorting the strings the pointers point at.

*PtrIter* is a tool that can be used to construct such a support vector, as shown in the **EXAMPLE** section.

*PtrIter* is a class template requiring one template type parameter: *Iterator*, the iterator’s type (e.g., *vector\<string\>::iterator*)

*PtrIter*’s users don’t have to specify *PtrIter*’s template type. The function template *ptrIter*, when provided with an iterator returns the matching *PtrIter* object.

## NAMESPACE

**FBB**\
 All constructors, members, operators and manipulators, mentioned in this man-page, are defined in the namespace **FBB**.

## INHERITS FROM

*std::iterator\<std::input\_iterator\_tag, ...\>*

## FREE FUNCTION

- o

  **PtrIter\<Iterator\> ptrIter(Iterator const &iter)**:\
   this function template returns a *PtrIter* object for the function’s *Iterator* argument. This function template simplyfies the construction of a *PtrIter* as no template parameters need to be specified (see also the **EXAMPLE** section)

## CONSTRUCTORS

- o

  **PtrIter(Iterator const &iter)**:\
   The *iter* parameter must be initialized with an existing input iterator, offering *operator\*, operator++, operator==* and *operator!=*. As *PtrIter* is a class template, its template type parameters must be specified when defining a *PtrIter* object. E.g.,

  ```
      PtrIter<set<string>::iterator> PtrIter(mySet.begin());
  ```

Copy and move constructors (and assignment operators) are available.

## OVERLOADED OPERATORS

- o

  **PtrType operator\*() const**:\
   the address of the entity the iterator refers to is returned;

- o

  **PtrIter &operator++()**:\
   the iterator is (pre)incremented to the next position;

- o

  **bool operator==(PtrIter const &other) const**:\
   *true* is returned if the two iterators are equal;

- o

  **bool operator!=(PtrIter const &other) const**:\
   *true* is returned if the two iterators are unequal;

## USING DECLARATION

The *PtrIter* class template defines *PtrType*:

- o

  **using PtrType = decltype(&\*Iterator())**:\

## MEMBER FUNCTIONS

All members of *std::iterator\<std:::input\_iterator\_tag, ...\>* are available, as **FBB::PtrIter** inherits from this class.

## EXAMPLE

```
#include <algorithm>
#include <unordered_map>
#include <vector>
#include <cstring>
#include <iostream>
#include <bobcat/ptriter>
using namespace std;
using namespace FBB;
int main()
{
    cout << "Enter lines, the first word will be the map’s key; "
                                            "^D when done.\n";
    string key;
    string line;
    unordered_map<string, string> map;
    while (cin >> key && getline(cin, line))    // fill the map
        map[key] = line;
    cout << ’\n’;
                                        // initialize a support
    vector<decltype(&*map.begin())>     // vector, using ptrIter
        support(ptrIter(map.begin()), ptrIter(map.end()));
                                        // sort ’support’
    typedef unordered_map<string, string>::value_type VT;
    sort(support.begin(), support.end(),
        [&](VT const *p1, VT const *p2)
        {
            return strcasecmp(p1->first.c_str(), p2->first.c_str()) < 0;
        }
    );
    for(auto &element: support)         // display sorted by key
        cout << element->first << ’ ’ << element->second << ’\n’;
}
```

## FILES

*bobcat/ptriter* - defines the class interface

## SEE ALSO

[**bobcat**(7)](/bobcat/7.md)

## BUGS

None Reported.

## BOBCAT PROJECT FILES

- o

  *https://fbb-git.gitlab.io/bobcat/*: gitlab project page;

Debian Bobcat project files:

- o

  *libbobcat6*: debian package containing the shared library, changelog and copyright note;

- o

  *libbobcat-dev*: debian package containing the static library, headers, manual pages, and developer info;

## BOBCAT

Bobcat is an acronym of \`Brokken’s Own Base Classes And Templates’.

## COPYRIGHT

This is free software, distributed under the terms of the GNU General Public License (GPL).

## AUTHOR

Frank B. Brokken (**f.b.brokken@rug.nl**).