Untitled

#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;
}