Programming

#include <iostream>
#include <cstring>
#include <exception>
#include <new>
#define ALLOC(N) (char*) new char[sizeof(char)*(N)]
#define DELETE(P) delete[] ((char*)(P))

class String {
public:
    // conversions: to C-like type char 
    operator const char*() const { return _str; }

    explicit String(const char* s = (char*)0) {
        if (s) {
            try {
                if (!(_str = new char[strlen(s) + 1])) {
                    std::bad_alloc ba;
                    throw ba;
                }
                strcpy(_str, s);
            } catch (std::exception e) {
                std::cout << e.what() << std::endl;
            }
        } else {
            _str = new char[1];
            *_str = 0;
        }
    }

    /*String (const String& obj) : _str(NULL) {
        if (obj._str) {
            this->_str = new char[strlen(obj._str) + 1];
            strcpy(_str, obj._str);
        } 
    }*/


    String (const String& obj) : _str(new char[obj.len() + 1]) {
        strcpy(_str, obj._str);
    }

    virtual ~String() {
        delete [] ((char*) _str);
        _str = NULL;
    }

    bool operator != (const String& obj) {
        if (this != &obj) return true;
        else return false;
    }

    String& operator = (const String& rhs) {
        if (this != &rhs) /* self assignment check */ {
            this->~String(); // delete[] _str; 
            if (strlen(rhs._str)) {
                _str = new char[strlen(rhs._str) + 1];
                strcpy(_str, rhs._str);
            }
        }
        return *this;
    }

    String& operator = (const char* rhs) {
        this->~String();
        if (strlen(rhs)) {
            _str = new char[strlen(rhs) + 1];
            strcpy(_str, rhs);
        }
        return *this;
    }

   String& operator += (const String& str) {
      // char *temp = new char[strlen(this->str) + strlen(obj.str) ? strlen(obj.str) : 0 + 1];
     /*  if (str) {
          char *temp = new char[strlen(str)];
          strcpy(temp, str);
      delete [] ((char *) str);
          str = new char[strlen(this->str) + strlen(obj.str) ? strlen(obj.str) : 0 + 1];
      strcpy(str, temp);
      if (strlen(obj.str)) strcat(str, obj.str);
       } else {
          str = new char[strlen(obj.str) ? strlen(obj.str) : 0 + 1];
      if (strlen(obj.str)) strcpy(str, obj.str);
       }*/
       return *this;
   }


    String& operator + (const String& obj) {
        return operator += (obj);
    }

    int strlen(const char *s) {
        if (!s) return 0;
        const char *tmp = s;
        while (*s) s++;
        return s - tmp;
    }

    void strcpy(char *dest, const char *src) {
        while ((*dest++ = *src++));
    }

    size_t len() const {
        return strlen(this->_str);
    }

    char* retString() const { return _str; }

private:
    char* _str;
};


int main() {
    String obj1("World");
    //   String obj2("Ibrahim");
    String obj2(obj1);
    //   obj1 +=" ";
    //obj1 += obj2;
    std::cout << obj1.retString() << std::endl;
    std::cout << obj2.retString() << std::endl;
}

 return ::strlen(this->_str);