#include <string.h>

#include <iostream>

#include <string>

using namespace std;


template<class myType>
class CfastString
{
	myType* _pStringStart;
	myType* _pStringEnd;

	void alignCopy(char* pCstr)
	{
		//align strlen(pCstr) to sizeof(myType)

		int length = strlen(pCstr);
		int alignedLength = (length + sizeof(myType) - length % sizeof(myType) ) / sizeof(myType);

		//set up pointers

		if( _pStringStart != NULL) delete[] _pStringStart;

		_pStringStart = new myType[alignedLength];
		_pStringEnd = _pStringStart + alignedLength;

		//set last sizeof(myType) bytes to NULL for safety

		_pStringStart[alignedLength-1] = 0;

		//copy to string

		strcpy((char*) _pStringStart, pCstr);	
	}

public:
	CfastString()
	{
		_pStringStart = NULL; _pStringEnd = NULL;
	}
	CfastString(char* pCstr)
	{
		_pStringStart = NULL; _pStringEnd = NULL;
		set(pCstr);
	}

	~CfastString()
	{
	//	delete[] _pStringStart;

	}
	
	void set(char* pCstr)
	{
		alignCopy(pCstr);
	}
	
	bool compare(CfastString fString)
	{
		myType* pString1 = _pStringStart;
		myType* pString2 = fString._pStringStart;
	
		while( pString1 != _pStringEnd)
		{
			if (*pString1 == *pString2) {
				*pString1++;
				*pString2++;
			}else
				return false;
		}
			return true;
	}

	char* pCstr()
	{
		return (char*)_pStringStart;
	}

};	//eoc CfastString


int main(int argc, char* argv[])
{
	CfastString<int> fStr1("nickkasdfa");
	CfastString<int> fStr2("nickkasdfa");

	//compare works

	if (fStr1.compare (fStr2) ) 
		cout << "same\n";
	else
		cout << "not same\n";

	//pCstr works

	cout << fStr1.pCstr() << endl;
	cout << fStr2.pCstr() << endl;

	cin.get();
	
	return 0;
}


    

#include &ltstring>#include &ltstring.h> 

1. Why do you include both <string> and <string.h> if you''re not going to use std::string methods?
   
   
2. Why do you allow for an integer based string? UNICODE? I''m just asking what the rationale is behind the decision, not bashing it.
   
   
3. Will your compare method work on strings of basic template types?
   
   
4. I think the error lies in the allocation and copy wrangling used to transfer char * data into other types. You might want to perform your own copy operations (seek through the string until you find ''\0'', ensuring the data is properly aligned).
   

quote:
I think the error lies in the allocation and copy wrangling used to transfer char * data into other types.

quote:Original post by EvilCrap
omfg, please dont respond if you dont know what ur talking about.

quote:
string.h is for string ops on char*.

quote:
this unoptimized class is significantly faster than std string, which was the intention.

quote:
anyone: please dont respond if you dont know what your talking about, or dont bother to actually skim the source.

quote:Original post by EvilCrap
SabreMan: give me a break. dont preach that trash to me, i know how to make programs.

quote:
i want to write a fast string class cause i want to write a freakin fast string class. it may not have the functionality of std string cause its in development : its called unit testing, jackass.