Is this good, solid code?

#pragma once

class cString
{
private:
	// Variables
	char * string;
	int cStringLength;
	static const int STR_MAX = 25500;
	static bool stringsJoined;

	// Encapsulated Methods
	int GetStringLength(char*) const;
	void CopyToLocalString(char*);
	void DeleteLocalString();
	bool CompareStrings(char*) const;
	char * JoinStrings(char*);

public:
	// Constructors & Deconstructor
	cString();
	cString(char*);
	virtual ~cString();

	// Operator Overloads
	void operator = (cString&);
	void operator = (char*);
	operator char*();
	bool operator == (cString&) const;
	bool operator == (char*) const;
	char * operator + (cString&);
	char * operator + (char*);
	void operator += (cString&);
	void operator += (char*);

	// Accessor methods
	char * GetString() const { return this->string; }
	int Size() const { return this->cStringLength; }
};

#include "cString.h"

bool cString::stringsJoined = false;

cString::cString()
{
	this->string = 0;
}

cString::cString(char* String)
{
	this->string = 0;
	CopyToLocalString(String);
}

cString::~cString()
{
	DeleteLocalString();
}

int cString::GetStringLength(char * String) const
{
	// local variable
	int i;

	// Loop through the string until a null is found or
	// the max limit is reached
	for ( i = 0 ; i < STR_MAX ; i++ )
		if ( String[i] == 0 )
			break;

	// Return a -1 if the operation fails
	if ( i >= STR_MAX )
		return -1;
	// Return value of i if operation succeeds
	else
		return i;
}

void cString::CopyToLocalString(char * String)
{
	// Local variables
	int sourceLength;

	// Delete local string
	this->DeleteLocalString();

	// Once local string is cleared, begin copy operations.
	// -> Determine the length of the source string
	sourceLength = this->GetStringLength(String);
	// --> Ensure operation succeeded
	if ( sourceLength < 0 )
	{
		// If length of the source string failed the size check
		// create an empty string
		this->string = new char[1];
		this->string[0] = '\0';
		return;
	}

	// If length operation returned a valid value, continue
	// -> Set the cStringLength field to sourceLength + 1
	this->cStringLength = sourceLength + 1;
	// -> Create a new char array
	this->string = new char[this->cStringLength];
	// -> Copy the source string into the new array
	for ( int i = 0 ; i < this->cStringLength ; i++ )
		this->string[i] = String[i];
	// -> Null terminate the new string.
	this->string[this->cStringLength - 1] = '\0';
}

/*  cString Method : DeleteLocalString()
	Checks to see if data is stored behind the string pointer. If data
	is found, the char array is deleted and the pointer nullified.
*/
void cString::DeleteLocalString()
{
	if (this->string != 0)
	{
		delete this->string;
		this->string = 0;
	}
}

/*  cString Method : CompareStrings(char*)
	Compares the string in the char* pointer to the string
	currently held in the local string variable
*/
bool cString::CompareStrings(char * String) const
{
	// Local variables
	int compareStringLength = GetStringLength(String) + 1;
	int comparisonTotal;

	// Compare lengths
	comparisonTotal = ( cStringLength - compareStringLength );
	if ( comparisonTotal != 0 )
		return false;

	// If strings are equal lengths, begin character by
	// character comparison
	for ( int i = 0 ; i < cStringLength ; i++ )
	{
		comparisonTotal = ( this->string[i] - String[i] );
		// If the strings are different, total will != 0;
		if ( comparisonTotal != 0 )
			return false;
	}

	return true;
}

/*  cString Method : JoinStrings(char*)
	Concaternates the characters int char* parameter with the
	characters currently stored in the local string
*/
char * cString::JoinStrings(char* String)
{
	// Local variables
	int totalLength = this->cStringLength + ( GetStringLength(String) );
	int placeHolder = 0;

	// Create a new char array that will fit both strings + null
	char * strJoin = new char[totalLength];

	// Copy first string into array
	for ( placeHolder ; placeHolder < this->cStringLength ; placeHolder++ )
		strJoin[placeHolder] = this->string[placeHolder];

	placeHolder--;

	// Copy second string into array
	for (int i = 0 ; placeHolder < totalLength ; i++, placeHolder++ )
		strJoin[placeHolder] = String[i];

	// Add null terminator
	strJoin[totalLength - 1] = '\0';

	// Return the finished string
	return strJoin;
}

/* cString Operator Assignment Overloads */
// cString to cString copy
void cString::operator = (cString& cstring)
{
	if ( this == &cstring)
		return;
	else
		CopyToLocalString(cstring.string);
}
// char array to cString copy
void cString::operator = (char * string)
{
	if ( stringsJoined == true)
	{
		CopyToLocalString(string);
		delete string;	// Removes memory leak in joining operations
		string = 0;
		stringsJoined = false;
	}
	else
		CopyToLocalString(string);
}
cString::operator char*()
{
	return this->string;
}
/* cString comparison overloads */
// compare cString to cString
bool cString::operator == (cString & cstring) const
{
	if ( this == &cstring)
		return true;
	else
		return this->CompareStrings(cstring.GetString());
}
// compare cString to char string
bool cString::operator == (char * string) const
{
	return this->CompareStrings(string);
}
/* cString addition overloads */
// return a joined string, cString to cString
char * cString::operator + (cString & cstring)
{
	stringsJoined = true;
	return JoinStrings(cstring.GetString());
}
// return a joined string, cString to char string
char * cString::operator + (char * string)
{
	stringsJoined = true;
	return JoinStrings(string);
}
/* cString add then replace overloads */
// join cString to another cString
void cString::operator += (cString & cstring)
{
	char * tempString = this->JoinStrings(cstring.GetString());
	this->CopyToLocalString(tempString);
	delete tempString;
	tempString = 0;
}
// join cString to char string
void cString::operator += (char * string)
{
	char * tempString = this->JoinStrings(string);
	this->CopyToLocalString(tempString);
	delete tempString;
	tempString = 0;
}