#include <iostream>
#include <string>
#include <string.h>

class NullType {};

template <typename T, typename U>
struct Typelist
{
    typedef T Head;
    typedef U Tail;
};

template <typename T, typename TL>
struct StringChain
{
    StringChain(const T& t, const StringChain<typename TL::Head, typename TL::Tail>& tl) : head(t), tail(tl) {}

    template <typename X>
    StringChain<X, Typelist<T, TL> > operator()(const X& obj) const
    {
         return StringChain<X, Typelist<T, TL> >(obj, *this);
    }

    size_t getSize() const
    {
         return tail.getSize() + doGetSize(head);
    }

    void appendString(char* str_ptr, size_t& offset) const
    {
        tail.appendString(str_ptr, offset);
        offset += doAppendString(str_ptr + offset, head);
    }

    std::string str() const
    {
        std::string ret_string;
        ret_string.resize(getSize());
        size_t offset = 0;
        appendString(&ret_string[0], offset);
        return ret_string;
    }

    const T& head;
    const StringChain<typename TL::Head, typename TL::Tail>& tail;
};

template <>
struct StringChain<NullType, NullType>
{
public:
    template <typename X>
    StringChain<X, Typelist<NullType, NullType> > operator()(const X& obj) const
    {
        return StringChain<X, Typelist<NullType, NullType> >(obj, *this);
    }

    size_t getSize() const
    {
        return 0;
    }

    void appendString(char*, size_t&) const
    {
        return;
    }
};


template <size_t N>
size_t doGetSize(const char (&array)[N])
{
     return strnlen(array, N);
}

template <size_t N>
size_t doAppendString(char* str_ptr, const char (&array)[N])
{
     size_t length = doGetSize(array);
     memcpy(str_ptr, array, length);
     return length;
}

typedef StringChain<NullType, NullType> StrChain;

int main()
{
    std::cout << StrChain()("hello")(" ")("world")("!!").str() << std::endl;
    return 0;
}

