Thread: How to achieve generic code while specializing behavior?

Hey guys,

I was wondering if it's possible to write a generic-but-specialize-able code.

For example, I'm trying to build an iterator for a container. I want it to be bidirectional and I realize that my way of iterating either way in the container has roughly the same structure.

The iterator stores an 'Element' pointer and a 'State' type.

The container stores a vector of unique_ptr's to Elements. Each Element has a State of Default, Alive, Free or Boundary. While iterating, our state will never be Default. While we're either Alive or Free it's safe to treat the iterator's internal pointer as one to contiguous memory (because it's allocated as such [type of pointer is std::unique_ptr<Element<T> []>]). At the boundaries though we need much more special behavior.

Boundary types are Elements who contain a pointer to another Boundary Element on a separate block of memory. This way, the container can allocate its memory in blocks and they can be linked to provide a means of iteration.

The container also stores a copy of the address of the very first element and the very last element, both of which are type Boundary.

I have a step function whose skeleton looks like this:

Code:

template <class T> void ContainerIterator<T>::Step()
{
  if (state_ == Element<T>::State::Boundary) {
    if (element_ == container_.first_) {
      // forward: advance pointer
      // backward: just return
    }
    
    if (element_ == container_.last_) {
      // forward: just return
      // backward: retract pointer
    }
    
    // forward: ++element; 
    // backward: --element;
    state_ = element_->GetState();
  }

   /* ... */
}

So, instead of writing StepForward() or StepBackward() functions, how would I be able to get specialized behavior using compile-time constructs? Or is it even possible? I've been trying to approach this using lambdas or something conceptually similar and use a run-time construct.

I wound up settling for function pointers. But I'm pleased with the results. Here's the code if anyone wants to see. It's under container-iterator.hpp but all the files are kind of intertwined which is why I posted the github link.

Дякую, MutantJohn! Thank you, MutantJohn!

Originally Posted by Дмитро

Дякую, MutantJohn! Thank you, MutantJohn!

Lol you're welcome, I guess.

Originally Posted by Elysia

If you're going to use function pointers, you may as well use std::function for genericity.

That was actually one of my very first drafts!

I'm, of course, using Valgrind to help debug my code and I noticed a rather large increase in the number of allocations when I did use std::function. A little scary. Maybe I'm micro-optimizing but naked function pointers didn't seem any less attractive to me than using std::function.

But I will say this, the syntax for pointers to member functions is definitely not what I thought it would be, that's for sure. And when I was using std::function, I think I had to use std::bind and I was binding "this". How cool is that? It's the most JavaScript-y thing I've ever done in C++!

I see...

That's good advice. I'll give std::function a try again.

Ooh, the coolest part about C++ is that a declaration can have multiple definitions! That's literally one of the the biggest things I actually wind up missing from C++. Overloading, man. It's super awesome.

Also, a stateful​ lambda? What do you mean by that? Hold on, I'll just google it...

Thanks for the correction!

Also, how does "this" bind context in C++? Like, does the context ever change and I need to bind?

Omg you're right! My JavaScript is showing! This is just a pointer

You're awesome, Elysia. Thank you

No MutantJohn, you are awesome! Дякую, MutantJohn!

Originally Posted by Guest

No MutantJohn, you are awesome! Дякую, MutantJohn!

Code:

#include <iostream>

int main(void)
{
  char x[3] = [ 'l', 'o', 'l' ];
 
  for (size_t i = 0; i < 3; ++i) {
    std::cout << x[i] << std::endl;
  }

  return 0;
}