// Заголовок 
class nvString
{
public:
    // constructor
    nvString();

    // Construct a string from a char pointer
    nvString(const char* inStr);

    // Copy-constructor
    nvString(const nvString& inStr);

    // destructor
    virtual ~nvString();

    // Type cast to char pointer
    inline operator const char *() const
    { return m_buffer; }

    // Indexing operator
    inline char operator[](int i) const
    { return m_buffer[i]; }

    // Char pointer atribuition operator
    nvString& operator=(const char* inStr);

    // Atribuition operator
    nvString& operator=(const nvString& inStr);

    // Concatenation operator with a char pointer
    nvString operator+(const char* inStr);

    // Concatenation operator
    nvString operator+(const nvString& inStr);

    // Self-concatenation operator with a char pointer
    void operator+=(const char* inStr);
    
    // Self-concatenation operator
    void operator+=(const nvString& inStr);

    void Clear(void);
    
    // Find a sub-string in the string
    inline int Find(const char *str) const
    { 
        char *pos=strstr(m_buffer,str);
        if (pos == 0)
            return -1;
        return (int)(pos-m_buffer); 
    }

    // Find the first occurrence of a character in the string
    inline int Find(char c) const
    { 
        char *pos = strchr(m_buffer,c);
        if (pos == 0)
            return -1;
        return (int)(pos-m_buffer); 
    }

    // Find the last occurrence of a character in the string
    inline int FindLast(char c) const
    {
        char *pos = strrchr(m_buffer,c);
        if (pos == 0)
            return -1;
        return (int)(pos-m_buffer); 
    }

    // Change the 'i'-th character of the string
    inline void SetChar(int i,char c)
    { 
        if (i < (int)strlen(m_buffer)) 
            m_buffer[i] = c;
    }

    // Crop the first 'n' characters of the string
    inline void CropBegin(int n)
    { 
        if (n < (int)strlen(m_buffer))
        {
            strcpy(m_buffer,&m_buffer[n]);
        }
    }

    // equal compare operator
    inline int operator==(const char *str) const 
    { return strcmp(m_buffer,str)==0; }

    inline int operator!=(const char *str) const 
    { return strcmp(m_buffer,str)!=0; }

    inline int operator>(const char *str) const 
    { return strcmp(m_buffer,str)>0; }

    inline int operator<(const char *str) const 
    { return strcmp(m_buffer,str)<0; }

    inline int operator>=(const char *str) const 
    { return strcmp(m_buffer,str)>=0; }

    inline int operator<=(const char *str) const 
    { return strcmp(m_buffer,str)<=0; }

    // Compare with a char pointer
    inline int Compare(const char *str) const
    { return strcmp(m_buffer,str); }

    // Compare the first 'n' characters of the string with a char pointer
    inline int Compare(const char *str,int n) const
    { return strncmp(m_buffer,str,n); }

    // Compare with a char pointer, case-insensitive flavour
    inline int CompareNoCase(const char *str) const
    { return stricmp(m_buffer,str); }

    // Change all characters to lower-case
    inline void ToLower()
    { strlwr(m_buffer); }

    // Change all characters to upper-case
    inline void ToUpper()
    { strupr(m_buffer); }

    // Return the length of the string in bytes
    inline int Length() const
    { return (int)strlen(m_buffer); }

private:
    char *m_buffer;
};

// тело
char* StrDuplicate(const char *str)
{
    char *strRet = new char[strlen(str)+1];
    assert(strRet);
    strcpy(strRet, str);
    return strRet;
}

nvString::nvString()
{
    m_buffer = StrDuplicate("");
}

nvString::nvString(const char* inStr)
{
    assert(inStr);
    m_buffer = StrDuplicate(inStr);
}

nvString::nvString(const nvString& inStr)
{
    assert(inStr.m_buffer);

    m_buffer = StrDuplicate(inStr.m_buffer);
}

nvString::~nvString()
{
    SafeArrayDelete(m_buffer);
}

void nvString::Clear(void)
{
  operator=("");
}

nvString& nvString::operator=(const char* inStr)
{
    assert(inStr);

    char *str = StrDuplicate(inStr);
    SafeArrayDelete(m_buffer);
    m_buffer = str;

    return *this;
}

nvString& nvString::operator=(const nvString& inStr)
{
    assert(inStr.m_buffer);

    char *str = StrDuplicate(inStr.m_buffer);
    SafeArrayDelete(m_buffer);
    m_buffer = str;

    return *this;
}

nvString nvString::operator+(const char* inStr)
{
    assert(inStr);

    nvString ret;

    int    len = (int)strlen(m_buffer) + (int)strlen(inStr)+1;
    char *str = StrDuplicate(m_buffer);
    assert(str);

    SafeArrayDelete(ret.m_buffer);

    ret.m_buffer = new char [len];
    assert(ret.m_buffer);

    strcpy(ret.m_buffer, str);
    strcat(ret.m_buffer, inStr);
    SafeArrayDelete(str);

    return ret;
}

nvString nvString::operator+(const nvString& inStr)
{
    assert(inStr.m_buffer);

    nvString ret;

    int    len = (int)strlen(m_buffer) + (int)strlen(inStr.m_buffer)+1;
    char *str = StrDuplicate(m_buffer);
    assert(str);

    SafeArrayDelete(ret.m_buffer);

    ret.m_buffer = new char [len];
    assert(ret.m_buffer);

    strcpy(ret.m_buffer, str);
    strcat(ret.m_buffer, inStr.m_buffer);
    SafeArrayDelete(str);

    return ret;
}

void nvString::operator+=(const char* inStr)
{
    assert(inStr);

    int    len = (int)strlen(m_buffer) + (int)strlen(inStr)+1;
    char *str = StrDuplicate(inStr);
    char *strOld = StrDuplicate(m_buffer);

    SafeArrayDelete(m_buffer);
    m_buffer = new char[len];
    strcpy(m_buffer,strOld);
    strcat(m_buffer,inStr);
    SafeArrayDelete(str);
    SafeArrayDelete(strOld);
}

void nvString::operator+=(const nvString& inStr)
{
    assert(inStr.m_buffer);

    int    len = (int)strlen(m_buffer) + (int)strlen(inStr.m_buffer)+1;
    char *str = StrDuplicate(inStr.m_buffer);
    char *strOld = StrDuplicate(m_buffer);

    SafeArrayDelete(m_buffer);
    m_buffer = new char[len];
    strcpy(m_buffer,strOld);
    strcat(m_buffer,inStr.m_buffer);
    SafeArrayDelete(str);
    SafeArrayDelete(strOld);
}