Thread: Templated Function Typedef

Functions aren't types, so you can't use typedef.

First, though, is the direction as a compile-time parameter a good idea? I doubt it.

Anyway, you can make wrapper functions:

Code:

inline string getSmallestWord(Sequence &wordsList)
{
  return getAbsoluteWord<-1>(wordsList);
}

Nevertheless, I recommend you make the compare direction a runtime parameter.

It's not so much a readability problem; I simply think that if you implement it correctly, the slowdown will be unnoticeable, and you have the advantage of being able to decide at runtime which mode you want.

You could use a define:

Code:

#define getSmallestWord getAbsoluteWord<-1>

But maybe there's a good reason not to do that...

I was using a preprocessor statement similar to yours except with parenthesis, however, I think that the pure C++ approach with inline functions is much more in the nature of good coding. The typedef with the function pointer came to mind actually but I decided not to do it because it's kinda messy with the extra variables and stuff.

The compile-time template parameter versus a runtime parameter is really a choice dependant on the usage of the function. This is a simple dumb little program for my C++ class I'm forced to take (there's no placement test and I already skipped the first two courses in the programming track). The templated function impressed a ton of people. And yeah, the speed difference is neglible too. It's probably better to make it a runtime parameter but who really cares.

If anybody is interested, here's that section of the code with tons of comments taken out for breivity. As you can tell, the implementation isn't messy at all.

Code:

// Returns the alphabetical absolute word of the sequence, depending on the direction.
//   <compareDirection>: Positive stands for the greatest word, negative stands for the smallest word, alphabetically.
//   wordsList: The sequence of words to process.
template <int compareDirection>
static string getAbsoluteWord(Sequence &wordsList)
{
  // Set the first word of the sequence as the absolute word.
  string absoluteWord = wordsList[0];

  // Loop through all the words past the first one.
  int count = wordsList.size();
  for (int i = 1; i < count; ++i)
  {
    const string &currentWord = wordsList[i];
    int comparison = currentWord.compare(absoluteWord) * compareDirection;

    // If this word is "greater" than the current absolute word, then it should be the new absolute word.
    if (comparison > 0)
    {
      absoluteWord = currentWord;
    }
  }

  return absoluteWord;
}


// Returns the smallest word in the sequence.
//   wordsList: The sequence of words to process.
static inline string getSmallestWord(Sequence &wordsList)
{
  return getAbsoluteWord <-1> (wordsList);
}


// Returns the largest word in the sequence.
//   wordsList: The sequence of words to process.
static inline string getLargestWord(Sequence &wordsList)
{
  return getAbsoluteWord <1> (wordsList);
}

Originally Posted by JaWiB

But maybe there's a good reason not to do that...

You're using the preprocessor and there's a different way. Reason enough for me, anyway.
OK, for the sake of absurdity, here's an obscure example that fails. There's a template class that takes, as a type parameter, a function pointer:

Code:

template < string(*)(Sequence&) >
class Whee;

Now he wants to instantiate:

Code:

Whee<getSmallestWord> obj;

The CPP transforms this to:

Code:

Whee<getAbsoluteWord<-1>> obj;

Which, as everyone knows, is invalid.


OK, just looked at the code. It really wouldn't make a difference in speed. That's one memory access more, at most.