---

stringbuf.hpp

См. документацию.

/*
 * Copyright (C) Sergey P. Derevyago, 2003-2004.
 *
 * Permission to copy, use, modify, sell and distribute this software is granted
 * provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied warranty, and
 * with no claim as to its suitability for any purpose.
 *
 */

#ifndef __STRINGBUF_HPP__
 #define __STRINGBUF_HPP__

#include <string>
#include "fix_alloc.hpp"

namespace StringBuf_private {

 template <class T>
 struct Node {
        T val;
        Node* next;

        Node(const T& v) : val(v), next(0) {}

        void* operator new(size_t) { return fixed_alloc<Node>::alloc(); }

        void operator delete(void* ptr, size_t)
        {
         fixed_alloc<Node>::free(ptr);
        }
 };

 template <class T>
 struct List {
        Node<T>* head;
        Node<T>* tail;

        List() { head=tail=0; }

        ~List();

        void add(const T& v);
 };

 template<class T>
 List<T>::~List()
 {
  for (Node<T> *ptr=head, *next; ptr; ptr=next) {
      next=ptr->next;
      delete ptr;
  }
 }

 template <class T>
 inline void List<T>::add(const T& v)
 {
  Node<T>* n=new Node<T>(v);

  if (!head) head=tail=n;
  else tail=tail->next=n;
 }

}

class StringBuf {
      StringBuf_private::List<const std::string*> ptrs;
      StringBuf_private::List<std::string> tmps;

      StringBuf(const StringBuf&);
      StringBuf& operator=(const StringBuf&);

 public:
      StringBuf() {}

      StringBuf(const std::string& str) { *this+str; }

      StringBuf& operator+(const std::string& str);

      StringBuf& operator+(int val);

      StringBuf& operator+(unsigned int val);

      StringBuf& operator+(long val);

      StringBuf& operator+(unsigned long val);

      operator std::string() const;
};

inline StringBuf& StringBuf::operator+(const std::string& str)
{
 ptrs.add(&str);
 return *this;
}

#endif

---