将可选的迭代器传递给函数

Question

Is it possible to define an optional iterator to a function that will change the behaviour of the function based on its presence or not?

To give a concrete example consider the definition

template<typename Graph,
    typename random_access_iterator_distances,                        
    typename random_access_iterator_predecessors,                     
    typename back_insertor_iterator_frontier,                         
    typename back_insertor_iterator_explored >
    void dijkstra(const Graph &g,                                     
            const typename boost::graph_traits < Graph >::vertex_descriptor source,    
            random_access_iterator_distances   distances,             
            random_access_iterator_predecessors predecessors,         
            const typename boost::graph_traits < Graph >::vertex_descriptor target = -1,
            back_inserter_iterator_frontier frontier = null_iterator,                 
            back_inserter_iterator_explored explored = null_iterator );

Where the null_iterator would be some value that indicates the user does not want this output.

The work-around for this by defining two separate functions, one with frontier and explored in the definition, another without it, would not be a good alternative, because it would require duplication of code (since the logic in the function is tightly coupled with whether either frontier or explored is present.)

Is there somekind of pattern or replacement of null_iterator to make this type of code realizable in C++?

Answer 1

The easiest solution is to write a simple DevNullIterator. Since it's operator* doesn't do anything, it's trivially inlined and compiles away.

struct DevNull {
  template<typename T> operator=(T const&) { }
  template<typename T> operator T&() { static T dummy; return dummy; }
};

struct DevNullIterator {
  DevNull operator*() const { return DevNull();}
  DevNullIterator operator++() const { return *this; }
};

Answer 2

Is it possible to define an optional iterator to a function that will change the behaviour of the function based on its presence or not?

No. This is not possible. There are two candidates;

1. Overloading. Overloading creates a new function (with the same name), so this does not meet your needs.
2. Default arguments. There is no way to distinguish whether an argument comes from the user of the function or from the default.

Answer 3

Thanks to KeresSB comment, I ended up coming up with what I think is a clean solution. Essentially, I use the following pattern:

typedef struct _undefinded {
}undefined_t;

template<typename Graph,
    typename random_access_iterator_distances,
    typename random_access_iterator_predecessors,
    typename back_inserter_iterator_frontier = undefined_t,
    typename back_inserter_iterator_explored = undefined_t >
    void dijkstra(const Graph &g,
            const typename boost::graph_traits < Graph >::vertex_descriptor source,
            random_access_iterator_distances   distances,
            random_access_iterator_predecessors predecessors,
            const typename boost::graph_traits < Graph >::vertex_descriptor target = -1,
            boost::optional<back_inserter_iterator_frontier> frontier = boost::optional<back_inserter_iterator_frontier>(),
            boost::optional<back_inserter_iterator_explored> explored = boost::optional<back_inserter_iterator_explored>() );

Then inside the code of the function, it is possible to check if either frontier or explored are defined with

        if ( frontier.is_initialized() ) {
        } else {
            std::cout << "frontier is uninitialized!" << std::endl;   
        }
        if ( explored.is_initialized() ) {
        } else {
            std::cout << "explored is uninitialized!" << std::endl;   
        }