codice:
#include "StringBuffer.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <malloc.h>

StringBuffer::StringBuffer() throw()
{
	this->capacity = 32;
	this->factor = 50;
	this->length = 0;
	this->original_capacity = 32;
	buffer = (char*)malloc(32);
	if (buffer==NULL)throw;
	buffer[0]='\0';
}

StringBuffer::StringBuffer(int capacity, unsigned int factor) throw()
{
	this->capacity = capacity;
	this->factor = factor;
	this->length = 0;
	this->original_capacity = capacity;
	buffer = (char*)malloc(capacity+1);
	if (buffer==NULL)throw;
	buffer[0]='\0';
}

//these Append method must be protected against multithread collisions
//if necessary

void StringBuffer::Append(int n) throw()
{
	char num[80]; 
	itoa( n, num, 10);
	try{
		Append(num);
	}
	catch(void)
	{
		throw;
	}
}

void StringBuffer::Append(int n, int radix) throw()
{
	char num[80]; 
	itoa( n, num, radix);
	try{
		this->Append(num);
	}
	catch(void)
	{
		throw;
	}
}
void StringBuffer::Append(char c) throw()
{

	try{
		EnsureCapacity(length + 2);
	}
	catch(void)
	{
		throw;
	}
	buffer[length++]=c;
	buffer[length]='\0';
}
void StringBuffer::Append(double n) throw()
{
	char dbl[256];
	sprintf(dbl, "%f", n);
	try{
		Append(dbl);
	}
	catch(void)
	{
		throw;
	}
}

//Assume that c is terminated by zero
void StringBuffer::Append(char* c) throw()
{
	try{
		EnsureCapacity(length + strlen(c) + 1);}
	catch(void){
		throw;}
	
	strcat(buffer, c);
	length += strlen(c);
}

//return the actual capacity of the buffer
int StringBuffer::Capacity()
{
	return capacity;
}

//return the size of the actually used buffer (excluded the terminator)
//that is equal to the length of the contained string
int StringBuffer::Length()
{
	return length;
}
	//if n is greater than Capacity() then the capacity is increased by
	//a factor while internal capacity is not greater than n
void StringBuffer::EnsureCapacity(unsigned int n) throw()
{
	unsigned int oldcapacity	= capacity;

	while (capacity < n)
	{		
		capacity += capacity * factor / 100;
		if(capacity <= oldcapacity)capacity=oldcapacity+1;
	}

	if(oldcapacity != capacity)
	{
		char * newbuffer;
		newbuffer =(char*) realloc(buffer, capacity);
		if(newbuffer == NULL) throw;
		buffer = newbuffer;
	}
}

	//frees the unused portion of the buffer
void StringBuffer::TrimBuffer()
{
	char * newbuffer;
	newbuffer = (char*)realloc(buffer, length + 1);
	buffer = newbuffer;
}

//return a pointer to the buffer. The buffer is returned as string 
//of chars terminated by zero
char * StringBuffer::GetBuffer()
{
	return buffer;
}

	//Allocates new memory and copies the content of buffer into the new location
	//the original buffer remains unaltered. Note that the dimension
	//of the newly allocated memory is trimmed to the length (not capacity) of 
	//the original buffer
char * StringBuffer::CopyBuffer() throw()
{
	char * p;
	p = (char*) malloc(length + 1);
	if (p==NULL) throw;
	strcpy(p, buffer); //buffer is certainly terminated by zero
	return p;
}

//creates a new buffer with 32 byte of capacity 
//mantaining original increment	
//the original buffer is cleanly destroyed
void StringBuffer::ReInit() throw()
{
	Free();
	capacity = original_capacity;

	buffer =(char*) malloc(capacity);
	if (buffer==NULL)throw;
} 

//the original buffer is destroyed and capacity is set to 0
void StringBuffer::Free()
{
	if(buffer)
		free(buffer);
	length=0;
	capacity=0;
}

void StringBuffer::Empty()
{
	length=0;
	buffer[0]='\0';
}

int StringBuffer::GetCharAt (unsigned int pos)
{
	if (pos > length) return -1;
	return buffer[pos];

}