// ================= File MyStr.h
#ifndef _MyStr_H
#define _MyStr_H

class MyStr
{
    char* p;

    MyStr (int len);
public:
    MyStr (const char* s = "");
    MyStr (const MyStr &b);
    ~MyStr ();

    void xuat () const;
    void nhap ();

    MyStr& NoiVaoCuoiChuoi (const char* s);
    MyStr& NoiVaoCuoiChuoi (const MyStr& b);
    MyStr& operator+= (const char* s);
    MyStr& operator+= (const MyStr& b);

    MyStr& operator= (const char* s);
    MyStr& operator= (const MyStr& b);

    MyStr Noi2Chuoi (const char* s) const;
    MyStr Noi2Chuoi (const MyStr& b) const;
friend MyStr Noi2Chuoi (const char* t, const char* s);
friend MyStr Noi2Chuoi (const char* s, const MyStr& b);
    MyStr operator+ (const char* s) const;
    MyStr operator+ (const MyStr& b) const;
/*friend    MyStr operator + (const char* t, const char* s);
friend  MyStr operator + (const char* s, const MyStr& b);*/

friend ostream& operator<< (ostream& os, const MyStr& b);
friend istream& operator>> (istream& is, MyStr& b);

    MyStr SubMyStr (int begin, int end) const;
    MyStr Left (int len = -1) const;
    MyStr Mid (int begin, int len = -1) const;

    int TimViTri (const char* s, int start = 0) const;
    int TimViTri (const MyStr& s, int start = 0) const;
};

#endif // _MyStr_H

// ================= File MyStr.cpp
#include <iostream>
using namespace std;
#include <cstring>
#include "MyStr.h"

MyStr::MyStr (int len)
{
    p = new char[len + 1];
}

MyStr::MyStr (const char* s)
{
    p = strdup(s);
}

MyStr::MyStr (const MyStr &b)
{
    p = strdup(b.p);
}

MyStr::~MyStr ()
{
    delete[] p;
}

//---------------------- Xuat - Nhap ------------------------
void MyStr::xuat () const
{
    cout << p << '|' << endl;
}

void MyStr::nhap ()
{
    const int MAX = 100;
    char buf[MAX];
    cin.getline (buf, sizeof(buf));

    if (strlen (p) <= strlen (buf))
    {
        delete[] p;
        p = strdup (buf);
    }
    else
        strcpy (p, buf);
}


//---------------------- Noi vao cuoi chuoi ------------------------
MyStr& MyStr::NoiVaoCuoiChuoi (const char* s)
{
    MyStr res (strlen(p) + strlen(s));
    strcpy (res.p, p);  // 2: MyStrCopy p -> pNew
    strcat (res.p, s);  // 3: MyStrCat s -> pNew
    //delete[] p;       // 4: delete p
    p = strdup(res.p);  // 5: pNew -> p

/*  char* pNew;
    pNew = new char[strlen(p) + strlen(s) + 1]; // 1: new pNew
    strcpy (pNew, p);   // 2: MyStrCopy p -> pNew
    strcat (pNew, s);   // 3: MyStrCat s -> pNew
    //delete[] p;       // 4: delete p
    //p = pNew; // 5: pNew -> p
    p = strdup (pNew);
    delete[] pNew;*/

    return *this;
}

MyStr& MyStr::NoiVaoCuoiChuoi (const MyStr& b)
{
    this->NoiVaoCuoiChuoi(b.p);

    return *this;
}

MyStr& MyStr::operator+= (const char* s)
{
    this->NoiVaoCuoiChuoi(s);

    return *this;
}

MyStr& MyStr::operator+= (const MyStr& b)
{
    return *this += b.p;
}


//---------------------- Noi 2 chuoi ------------------------
MyStr& MyStr::operator= (const char* s)
{
    if (strlen (p) <= strlen (s))
    {
        delete[] p;
        p = strdup(s);
    }
    else
        strcpy (p, s);

    return *this;
}

MyStr& MyStr::operator= (const MyStr& b)
{
    return *this = b.p;
}

MyStr MyStr::Noi2Chuoi (const char* s) const
{
    MyStr res (strlen(p) + strlen(s)); // 1: new MyStr
    strcpy (res.p, p);  // 2: MyStrCopy p -> pNew
    strcat (res.p, s);  // 3: MyStrCat s -> pNew

    return res;
}

MyStr MyStr::Noi2Chuoi (const MyStr& b) const
{
    return this->Noi2Chuoi(b.p);
}

MyStr MyStr::operator+ (const char* s) const
{
    return this->Noi2Chuoi(s);
}

MyStr MyStr::operator+ (const MyStr& b) const
{
    return *this + b.p;
}

MyStr Noi2Chuoi (const char* t, const char* s)
{
    MyStr res (strlen(t) + strlen(s)); // 1: new MyStr
    strcpy (res.p, t);  // 2: MyStrCopy p -> pNew
    strcat (res.p, s);  // 3: MyStrCat s -> pNew

    return res;
}

MyStr Noi2Chuoi (const char* s, const MyStr& b)
{
    return Noi2Chuoi(s, b.p);
}

/*MyStr operator + (const char* t, const char* s)
{
    MyStr res (strlen(t) + strlen(s)); // 1: new MyStr
    strcpy (res.p, t);  // 2: MyStrCopy p -> pNew
    strcat (res.p, s);  // 3: MyStrCat s -> pNew

    return res;
}

MyStr operator + (const char* s, const MyStr& b)
{
    MyStr res (strlen(s) + strlen(b.p)); // 1: new MyStr
    strcpy (res.p, s);  // 2: MyStrCopy p -> pNew
    strcat (res.p, b.p);    // 3: MyStrCat s -> pNew

    return res;
}*/


//---------------------- Xuat Nhap ------------------------
ostream& operator<< (ostream& os, const MyStr& b)
{
    return os << b.p << '|';
}

istream& operator>> (istream& is, MyStr& b)
{
    const int MAX = 256;
    char buf[MAX];
    is.getline (buf, sizeof (buf));

    b = buf;

    return is;
}


//---------------------- Lay chuoi ------------------------
MyStr MyStr::SubMyStr (int begin, int end = -1) const
{
/*  !!!! Goi y:
    1. Chinh ly so lieu :   if: begin < 0   ----> begin = 0;
                            if: end > len (chieu dai cua chuoi)
                              or            ----> end = len
                                end < 0

    2. Tao chuoi con :  if: begin < end     ----> len = end - begin
                        else:               ----> chuoi rong
          1/    delete
          2/    new
          3/    strncpy // len = end - begin + 1
*/
    MyStr res (end - begin + 1);    // bien trung gian, chuoi rong
    int len = strlen (p) + 1;

    // 1. Chinh ly so lieu:
    if (begin < 0)
        begin = 0;
    if (end > len || end < 0)
        end = len;

    // 2. Tao chuoi con:
    if (begin < end)
    {
        len = end - begin + 1;
        strncpy (res.p, p + begin, len);
        res.p[len] = '\0'; // vi tri chuoi la ki tu NULL de cho thoat
    }

    return res;
}

MyStr MyStr::Left (int inLen) const
{
    MyStr res (inLen + 1);
    int len = strlen (p) + 1;

    // 1. Chinh ly so lieu:
    if (inLen < 0 || inLen > len)
        inLen = len;

    // 2. Tao chuoi con:
    len = inLen + 1;
    strncpy (res.p, p, len);
    res.p[len] = '\0';

    return res;
}

MyStr MyStr::Mid (int begin, int len) const // kho hiu
{
    // 1. Chinh ly so lieu
    MyStr res (len - begin + 1);
    if (begin < 0)
        begin = 0;
    if (len < begin)
        len = strlen (p) + 1;

    // 2. Tao chuoi con:
    strncpy (res.p, p + begin, len + 1);
    res.p[len + 1] = '\0';

    return res;
}

// ================= File Main.cpp
#include <iostream>
using namespace std;
#include <cstring>
#include "MyStr.h"

int main ()
{
    cout << "------ BAI TAP LOP MyStr ------\n"
        << "    (Ki tu | la ki tu NULL)\n\n";

/*  MyStr a, b;
    cout << "Nhap vao chuoi A: ";
    cin >> a;
    cout << " - Chuoi A: " << a << endl;
    cout << "Nhap vao chuoi B: ";
    cin >> b;
    cout << " - Chuoi B: " << b << endl;*/

    MyStr a("chao ban");
    MyStr b("bun wa");
    cout << " - Chuoi A: " << a << endl;
    cout << " - Chuoi B: " << b << endl;

    cout << "\n------------------------------------------------";
    cout << "\n --- (A + B) Noi chuoi A voi chuoi B ---\n";
    cout << "Chuoi dc noi: " << a + b << endl;
    cout << " - Chuoi A: " << a << endl;
    cout << " - Chuoi B: " << b << endl;

    cout << "\n------------------------------------------------";
    MyStr c = a;
    cout << "\n  -- (C = A) Tao chuoi C la chuoi A -- \n";
    cout << " - Chuoi C: " << c << endl;
    cout << " --- (c += B) Noi chuoi B vao chuoi C ---\n";
    cout << " - Chuoi A: " << a << endl;
    cout << " - Chuoi B: " << b << endl;
    cout << " - Chuoi C: " << (c += b) << endl;

    MyStr d = Noi2Chuoi("chan ge", b);
    cout << "\n --- (D = 'chan ge' + B) Tao chuoi D la chuoi A cong chuoi B --- \n";
    cout << " - Chuoi D: " << d << endl << endl;

    cout << " --- Lay chuoi ---\n";
    cout << "Lay trong chuoi D tu ky tu 1 -> 5: "
         << d.SubMyStr (1, 5) << endl;

    return 0;
}