My own C++ Format function

In my opinion:

• Use fullscope names (like std::vector, boost::shared_ptr)
• Don't use const & for simple types (for example int or double)
• Write const after the type: std::string const&
• For string IntToString(...) and ToString(const double &val...) why you don't use std::ostringstream?
• In FormatNoVariadicTemplates.h why you don't use functions for FNVT_BEGIN and FNVT_END?

Have you any some benchmark results?

PS: good idea ;) I'm usually use to Qt functions, we are using this library in our projects or stl.

There are some serious portability-issues with the code:

• You do not have proper header guards. #pragma is non-standard.
• You do not have proper includes (because of a precompiled header, I presume).
• Names beginning with an underscore followed by an uppercase letter (e.g. _FinalizeFormat, _FindPlaceholder) are reserved by the compiler.

I have a few comments, in no particular order.

It seems to me like you can't decide between std::string and const char*. Pick one.

(Maybe I'll get flamed for this one.) You say you care about performance, but your use of vector and string tell a different story. It seems to me like heap allocation is completely unneccessary for most of this, and for this reason I would avoid STL and C++ strings. Or, if not avoiding them entirely, I would avoid using so many std::strings as temporaries while formatting. The functions that do this should maybe take a destination buffer as a parameter.

It seems strange that your internal representation of options remains a string at all times. For example:

static const char *normalStrings[] = { "true", "false" };
static const char *alternativeStrings[] = { "yes", "no" };
const bool alternative = (options == "a");
const char **strings = alternative ? alternativeStrings : normalStrings;

This itself is a bit hard for an outsider to follow as written, but aside from that, do you really wantoptions == "a"? What if you want more than one option? Wouldn't a check for a be more like strchr(options, 'a')? In which case I would say do you really want O(n) lookup for options? Maybe this doesn't make sense as a string. Maybe you want to store them internally as flags in an integer. Even if you don't want to combine options it still might look less weird as an enum or constant. There are a lot of magic literals floating around in this code.

There's lots of code that's more verbose than it has to be, for example:

/* Find the '{' */
for (int i = start; i < end; ++i)
{
    if (str[i] != '{')
        continue;

    /* Check if there is enough space for the minimum spaceholder length, 3: {.} */
    if (end - i < 3)
        continue;

The for loop seems to be reinventing strchr. I would much prefer something like this:

char *current, *end;

while ((current=strchr(str, '{')) &&
       (end=strchr(current, '}')))
{
   //
   // TODO: do something with placeholder at (current, end)
   //

   str = end + 1;
}

Or perhaps more C-like (though I realize you're writing C++ it looks like you've already rejected some of its idioms) would be something like this:

while (*str)
{
   if (*str == '{' &&
       (end=strchr(str, '}')))
   {
      //
      // TODO: evaluate placeholder at (str, end) into dst
      //

      str = end+1;
   }
   else
   {
      // TODO: make sure this doesn't overflow :-)
      *dst++ = *str++;
   }
}

IntToString could have a lot of improvements... One trivial stylistic thing is that "0123456789" is a lot easier on the eyes than { '0', '1', '2', ... }. More importantly, do you have to do this with a separate heap allocation? Maybe it should be passed a destination buffer. The reserve method being called with a constant also looks a bit weird because you've just done the conversion inside tmp, so you know the exact length...

Lastly, as a matter of habit, if you're going to use sprintf -- well don't. Use snprintf instead. (If you happen to be using a version of Visual Studio that doesn't have that, there's also sprintf_s or StringCchPrintf.)