"Type-safe" sprintf

Hello!

I have invented a simple sprintf-like function aimed at replacing sprintf.
The reason being that our code has a lot of dangerous sprintf's that nobody
here is interested in re-writing.

Here is the implementation of my sprintf-like function. It builds on
boost::format. This function is typesafe and provides error checking. It
will throw an exception if the output buffer is overrun, or there weren't
enough arguments.

What do you think?

#include <iostream>
#include <algorithm> // copy
#include <stdexcept> // std::logic_error
#include <string> // std::basic_string
#include <boost/format.hpp> // boost::basic_format

namespace cool
{
   namespace detail
   {
      template<class Char>
      class feeder
      { };

      template<class Char, std::size_t N>
      class feeder<Char[N]>
      {
         typedef typename boost::basic_format<Char> format_type;
         typedef typename std::basic_string<Char> string_type;

         format_type format;
         Char* buffer;
         bool first;

      public:

         feeder(Char* b)
            : buffer(b),
              first(true)
         { }

         ~feeder()
         {
            // I know it is bad to throw from destructor...
            string_type result = str(format);
            if( result.size()>=N )
               throw std::logic_error("too many arguments to sprintf");
            std::copy(result.begin(), result.end(), buffer);
            buffer[result.size()] = 0;
         }

         //! Might be the format string
         feeder& operator%(const Char* c)
         {
            if( first )
            {
               format.parse(c);
               first = false;
            }
            else
            {
               format % c;
            }

            return *this;
         }

         //! Can never be the format string
         template<class T>
         feeder& operator%(const T& c)
         {
            if( first )
            {
               throw std::logic_error("bad format string");
            }
            else
            {
               format % c;
            }

            return *this;
         }
      };
   }

   template<class Source>
   typename detail::feeder<Source> sprintf(Source& buffer)
   {
      typedef typename detail::feeder<Source> Feeder;
      return Feeder(buffer);
   }
}

int main()
{
   char buffer[1024];

   cool::sprintf(buffer) % "%d.%d" % 5 % 1;
   std::cout << "buffer=" << buffer << std::endl;

   char temp[1024];
   const int triangle_number = 15;
   cool::sprintf(temp) % "71....+TRI%013d " % triangle_number;
   std::cout << "temp=" << temp << std::endl;

   try
   {
      cool::sprintf(temp) % "71....+TRI%013d ";
   }
   catch( std::exception& ex )
   {
      std::cerr << ex.what() << std::endl;
   }

   wchar_t wideBuffer[10];
   cool::sprintf(wideBuffer) % L"%d.%d" % 5 % 1;
   std::wcout << "wideBuffer=" << wideBuffer << std::endl;

   return 0;
}

This prints:
buffer=5.1
temp=71....+TRI0000000000015
boost::too_few_args: format-string refered to more arguments than were
passed
wideBuffer=5.1

--
Daniel
A: Because it messes up the order in which people normally read text.
Q: Why is top-posting such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?