Manticore -- Custom String Class (Feedback)

[Lonely One]

Hello,

A couple of weeks ago I decided to test my knowledge I have gathered thus far and see if I could write my own string class. From what I have gathered from reading various websites is that writing your own string class in general is a bad idea. Manticore is NOT going to replace the already provided std::string class. It was a small project to test my knowledge.

I appreciate the feedback coming from more experienced coders. That is the primary reason why I decided to post my class here. I would like to apologize in advance if this is completely wrong.

_{For those who want to see it in action; http://prntscr.com/a8sy4h}

#ifndef _MANTICORE__H
#define _MANTICORE__H
#pragma once

#include <Windows.h>

class Manticore {
private:
	char m_OoB;
	char* m_Data;
	size_t m_Length;
	size_t m_BufferSize;

private:
	unsigned char srealloc(size_t);

public:
	Manticore ( const char* );
	Manticore ( const Manticore& );
	~Manticore ( );

	char& operator[] ( size_t );
	void operator+= ( const char* );
	void operator+= ( const Manticore& );

	void upper ( void );
	void lower ( void );
	void replace ( const char, const char );
	void reverse ( void );
	void append ( const char* );
	void trim ( void );

	size_t length ( void ) const;
	size_t size ( void ) const;
	const char* c_str ( void ) const;
};

#endif 

#include "stringmgr.h"

Manticore::Manticore(const char* pszData) {
	if ( !pszData || pszData[0] == '\0' )
		return; // FIX LATER

	size_t length = strlen ( pszData );
	this->m_Data = new char [ length + 1 ]();
	this->m_BufferSize = (length + 1);
	this->m_Length = length;
	this->m_OoB = 0;

	if ( !m_Data ) return; // FIX LATER

	memcpy( m_Data, pszData, length );
}

Manticore::Manticore(const Manticore& mCore) {
	this->m_Data = new char [ mCore.m_BufferSize ]();
	memcpy( this->m_Data, mCore.m_Data, mCore.m_Length );
	this->m_BufferSize = mCore.m_BufferSize;
	this->m_Length = mCore.m_Length;
	this->m_OoB = mCore.m_OoB;
}

Manticore::~Manticore() {
	delete[] m_Data;
};

unsigned char Manticore::srealloc(size_t nsize) {
	if ( !m_Data )
		return 1; // FIX LATER

	char* buffer = new char [ nsize + 1 ]();

	if ( !buffer )
		return 2; // FIX LATER

	memcpy ( buffer, m_Data, m_Length + 1 );
	delete[] m_Data;

	m_Data = buffer;
	m_BufferSize = ( nsize + 1 );

	return 0; // FIX LATER
}

char& Manticore::operator[](size_t index) {
	return ( ( index < 0 || index > this->m_Length ) ? this->m_OoB : this->m_Data [ index ] );
}

void Manticore::operator+=(const char* pszData) {
	this->append ( pszData );
}

void Manticore::operator+=(const Manticore& mCore) {
	this->append ( mCore.m_Data );
}

void Manticore::upper(void) {
	char* data = this->m_Data;
	unsigned int pos = 0;

	while ( pos < this->m_Length ) {
		if ( *(data + pos ) >= 'a' && *( data + pos ) <= 'z')
			*( data + pos ) -= ( 'a' - 'A' );
		pos++;
	}
}

void Manticore::lower(void) {
	char* data = this->m_Data;
	unsigned int pos = 0;

	while ( pos < this->m_Length ) {
		if ( *( data + pos ) >= 'A' && *( data + pos ) <= 'Z')
			*( data + pos ) += ( 'a' - 'A' );
		pos++;
	}
}

void Manticore::replace(const char dst, const char src) {
	char* data = this->m_Data;
	unsigned int pos = 0;

	while ( pos < this->m_Length ) {
		if ( *( data + pos ) == dst )
			*( data + pos ) = src;
		pos++;
	}
}

void Manticore::reverse(void) {
	char* data = this->m_Data;
	char* back = ( this->m_Data + ( this->m_Length - 1 ) );
	char buffer = 0;

	while ( back > data ) {
		buffer = *data;
		*data = *back;
		*back = buffer;
		data++; back--;
	}
}

void Manticore::append(const char* pszData) {
	size_t src_len = strlen ( pszData );
	size_t available = ( ( this->m_BufferSize - 1 ) - this->m_Length );

	if ( available < src_len || available == src_len )
		this->srealloc( ( this->m_Length + src_len ) );

	memcpy(this->m_Data + m_Length, pszData, src_len );
	this->m_Length += src_len;
}

void Manticore::trim(void) {
	char* front = this->m_Data;
	char* back = ( this->m_Data + this->m_Length ) - 1;
	size_t src_len = this->m_Length;

	while (*front && isspace((int)*front)) front++;
	while (src_len && *back && isspace((int)*back)) { src_len--; back--; }
	size_t new_size = ( back - front ) + 1;

	char* buffer = new char [ new_size + 1 ]();
	memcpy(buffer, front, new_size);

	delete[] this->m_Data;
	this->m_Data = buffer;

	this->m_BufferSize = ( new_size + 1 );
	this->m_Length = new_size;	
}

size_t Manticore::length(void) const {
	return this->m_Length;
}

size_t Manticore::size(void) const {
	return this->m_BufferSize;
}

const char* Manticore::c_str(void) const {
	return this->m_Data;
}

Update 1; Class updated with the feedback provided by kbw

[kbw]

Very good. I do have a few comments.

You need to implements the assignment operator too. operator=

What's the deal with MAX_BUFFER_SIZE? You don't actually have a maximum as you're getting your memory from the heap.

Concentrate on interface. How is someone going to use this object? Someone who uses a string who doesn't care about that srealloc thing or that xor madness. Whatever it is, it doesn't belong in the public interface.

c_str() should be a const member.

The member data should be private. No one should have access. Extending stuff is a matter of design, it can't be done properly by accident or convenience.

I hope you can now see the value of exceptions. It's the only way to handle some of those errors that you don't know what to do with.

[Lonely One]

@kbw,

Thank you very much for the feedback. I have re-worked the class a little bit. operator= will be added later today.

~ Lonely One