#include <iostream>
#include "String.h"
using namespace std;

namespace HomeMadeString {

	String::String() {pData=NULL; elementsNum=0;}

	String::String (const String & string) {pData=NULL; strcpy(*this, string);}

	String::String (const char* str)
	{
		elementsNum=strlen(str);
		if (elementsNum==0) {pData=NULL; return;}
		pData= new char [elementsNum];
		for (int i=0; i<elementsNum; i++) pData[i]=str[i];
	}

	String::String (const char c, unsigned int times)
	{
		elementsNum=times;
		if (!elementsNum) {pData=NULL; return;}
		pData= new char [elementsNum];
		for (int i=0; i<elementsNum; i++) pData[i]=c;
	}

	String::~String (void)
	{
		if (pData)
		{
			delete [] pData;
		}
	}

	void String::getStr(char *pBuff)
	{
		int i;
		for (i=0; i<elementsNum; i++) pBuff[i]=pData[i];
		pBuff[i]='\0';
	}

	void String::print(ostream &os)
	{
		for (int i=0; i<elementsNum; i++) os << pData[i];
	}

	char String::getChar(unsigned int pos)
	{
		if ((pos<0) || (pos>elementsNum)) return 0;
		return pData[pos];
	}

//6 db függvény az oldalról:

	String String::strcat(const String& string1, const String& string2)
	{
		String s;
		s.elementsNum=string1.elementsNum+string2.elementsNum;
		if (s.elementsNum==0) {s.pData=NULL; return s;}
		s.pData=new char [s.elementsNum];
		for (int i=0; i<string1.elementsNum; i++) s.pData[i]=string1.pData[i];
		for (int i=string1.elementsNum; i<string1.elementsNum+string2.elementsNum; i++)
			s.pData[i]=string2.pData[i-string1.elementsNum];
		return s;
	}

	/* OPERÁTORRAL ÍGY LENNE AZ STRCAT
	String String::operator+(const String& string){
		String s;
		s.elementsNum=(elementsNum+string.elementsNum);
		if(s.elementsNum==0){pData=NULL; return s;}
		s.pData= new char [s.elementsNum];
		for(int i=0; i<elementsNum; i++) {s.pData[i]=pData[i];}
		for(int i=elementsNum; i<(string.elementsNum+elementsNum); i++){s.pData[i]=string.pData[i-elementsNum];}
		return s;
	}*/


	String String::strncat(const String& string1, const String& string2, int hatar)
	{
		String s;
		s.elementsNum=string1.elementsNum+hatar;
		if (s.elementsNum==0) {s.pData=NULL; return s;}
		s.pData=new char [s.elementsNum];
		for (int i=0; i<string1.elementsNum; i++) s.pData[i]=string1.pData[i];
		for (int i=string1.elementsNum; i<string1.elementsNum+hatar; i++)
			s.pData[i]=string2.pData[i-string1.elementsNum];
		return s;
	}

	bool String::strcmp(const String& string1, const String& string2)
	{
		if (string1.elementsNum!=string2.elementsNum) return false;
		for (int i=0; i<string1.elementsNum; i++)
			if (string1.pData[i]!=string2.pData[i])
				return false;
		return true;
	}

	/*OPERÁTORRAL ÍGY LENNE AZ STRCMP
	bool String::operator==(const String & string)
	{
		if(string.elementsNum!=elementsNum)return false;
		for(int i=0; i<elementsNum; i++){
			if(string.pData[i]!=pData[i]) return false;}
		return true;
	}*/

	bool String::strncmp(const String& string1, const String& string2, int hatar)
	{
		if (string1.elementsNum!=string2.elementsNum) return false;
		for (int i=0; i<hatar; i++)
			if (string1.pData[i]!=string2.pData[i])
				return false;
		return true;
	}
	void String::strcpy(String &string1, const String &string2)
	{
		delete [] string1.pData;
		string1.elementsNum=string2.elementsNum;
		if (string1.elementsNum==0)
		{
			string1.pData=NULL;
			return;
		}
		string1.pData= new char [string1.elementsNum];
		for (int i=0; i<string1.elementsNum; i++)
			string1.pData[i]=string2.pData[i];
	}

	/*OPERÁTORRAL ÍGY LENNE AZ STRCPY
	String & String::operator=(const String &string)
	{

			delete[] pData;
			this->elementsNum=string.elementsNum;
			if(elementsNum==0){
				pData=NULL;
				return *this;}
			pData=new char [string.elementsNum];
			for(int i=0; i<string.elementsNum; ++i)
				pData[i]=string.pData[i];
		return *this;
	}*/

	void String::strncpy(String &string1, const String &string2, int hatar)
	{
		delete [] string1.pData;
		string1.elementsNum=hatar;
		if (string1.elementsNum==0)
		{
			string1.pData=NULL;
			return;
		}
		string1.pData= new char [string1.elementsNum];
		for (int i=0; i<hatar; i++)
			string1.pData[i]=string2.pData[i];
	}

}





#ifndef STRING_H
#define STRING_H
#include <iostream> // Für cout, <iosfwd> waere übrigens genug hier

namespace HomeMadeString // unser Namensbereich; alles liegt auf diesem Namensbereich
{
	class String
	{
		// Die aktuelle Anzahl von Zeichen
		unsigned int elementsNum;

		// Der Pointer auf dem dynamischen Speicherbereich wo die Zeichen sind
		char *pData;
	public:
		// Parameterloser Konstruktor
		String();

		// Kopierkonstruktor
		String (const String & string);

		// Konstruktor mit nullterminierten C-Zeichenkette
		String (const char* str);

		// Konstruktor mit einem Zeichen und mit einem unsigned int (times)
		// unser String wird mit "times" Stück von dem Zeichen "c" initialisiert
		String(char c, unsigned int times);

		// Destruktor:
		~String (void);

		// Inhalt des String-Objektes in den Puffer pBuff kopieren und mit Nullzeichen terminieren
		// (Sie sollen annehmen, daß der Puffer wird von dem Anwender allokiert und freigegeben)
		void getStr(char * pBuff);

		// Länge des Strings ermitteln
		unsigned int getLength() { return elementsNum; }

		// String in einem Ausgabestrom schreiben ('cout' ist vom Typ ostream.)
		// Wir werden nie "using namespace" in einer Header-Datei schreiben, sondern wir geben
		// explizit std::ostream an. In der .cpp-Datei aber dürfen wir schon, wenn wir wollen.
		void print(std::ostream& os);

		// Gibt das Zeichen in der Position pos zurück, oder 0 wenn die Position ungültig istsonst
		char getChar(unsigned int pos);

		// --- Statische Funktionen. Sie werden zwei String-Variablen verarbeiten. ---

		// Zwei Strings zusammenfügen und zurückgeben
		static String strcat(const String& string1, const String& string2);

		static String strncat(const String& string1, const String& string2, int hatar);

		// Zwei Strings vergleichen
		static bool strcmp(const String& string1, const String& string2);

		static bool strncmp(const String& string1, const String& string2, int hatar);

		// Das zweite String in die erste kopieren:
		static void strcpy(String& string1, const String& string2);
		static void strncpy(String& string1, const String& string2, int hatar);
	};
}
#endif /* STRING_H */




#include <iostream>
#include "String.h"

using namespace std;
using namespace HomeMadeString;



int main()
{
	// Den parameterlosen Konstruktor testen
	String s1;
	// Wir testen den Konstruktor, der eine C-String erwartet
	String s2 = "Hello, hello!"; // bedeutet eigentlich String s2 = String("Hello, hello!")

	// Ergebnisse ausgeben
	s1.print(cout);
	cout << endl;
	s2.print(cout);
	cout << endl << endl;

	// Die Kopierfunktion (statische Funktion) testen, Ergebnis ausgeben
	String::strcpy(s1,s2);
	s1.print(cout);
	cout << endl;
	s2.print(cout);
	cout << endl;

	if(String::strcmp(s1,s2))						//strcmp
		cout << "s1 and s2 are the same!!!" << endl;


	String s7;
	String s8= "Helka";
	s7.print(cout);
	cout << endl;
	s8.print(cout);
	cout << endl;
	String::strncpy(s7,s8,3);
	s7.print(cout);
	cout << endl;
	s8.print(cout);
	cout << endl;

	cout<<endl;

	String s5= "Hello";
	String s6= "Helka";
	s5.print(cout);							//strncmp itt csak az első három elem hasonlóságát vizsgálja
	cout << endl;
	s5.print(cout);
	cout << endl;
	String::strncmp(s5, s6,3);
	cout << "Helka and hello are the same, if you observe only 3 charakters of the string"<<endl;
	cout <<endl;
	s5.print(cout);
	cout << endl;
	s5.print(cout);
	cout << endl;




	// Den "Muster"-Konstruktor testen: String aus 15 Stück '-'
	String s3('-', 15);
	s3.print(cout);
	cout << endl;

	// Die concatenate Funktion und den Kopierkonstruktor testen
	String s4 = String::strcat(s2,s3);					//sima strcat, összefűz 2 sztringet
	s4.print(cout);
	cout << endl;


	String s9= String::strncat(s2, s3, 3);				//csak az első három elemét fűzi hozzá a második sztringnek
	s9.print(cout);
	cout<<endl;
	cout <<endl;

	// Die getChar Funktion (Indexierung) testen
	for(unsigned int i = 0; i < s4.getLength(); ++i)
	{
		cout << s4.getChar(i);
	}
	cout << endl;

	// getStr testen
	char *pStr = new char[s4.getLength()+1]; // Platz für das Ergebnis und Nullterminator
	s4.getStr(pStr);
	cout << pStr << endl;	// cout kennt auch C-Stringe!
	delete [] pStr;		// Buffer freigeben

	return 0;
}