String.cpp

#include "String.h"

void String::alloc(const size_t size_)
{
    data = new char[size_];
}

void String::dealloc()
{
    delete[] data;
    data = nullptr;
    size = 0;
}

void String::copy(const char* str)
{
    for (int i = 0; str[i] != '\0'; i++)
    {
        data[i] = str[i];
    }
}

void String::copy(const String& s)
{
    for (unsigned int i = 0; i < s.size; i++)
    {
        data[i] = s[i];
    }
}

size_t String::get_size(const char* str) const
{
    int i = 0;
    for (i = 0; str[i] != '\0'; i++)
        ;
    return i;
}

String::String(size_t size_ ) : size(size_), data(nullptr)
{
    alloc(size_);
}

String::String(unsigned int size_, unsigned int aski) : String(size_)
{
    for (unsigned int i = 0; i < size_; i++)
    {
        data[i] = aski;
    }
}

String::String(const char* str) : String(get_size(str))
{
    copy(str);
}

String::String(const String& rhs) : String(rhs.size)
{
    copy(rhs);
}

String::String(String&& rv) noexcept
{
    size = rv.size;
    data = rv.data;
}

String& String::operator=(const String& rhs)
{
    if (this != &rhs)
    {
        dealloc();
        size = rhs.size;
        alloc(size);
        copy(rhs);
    }

    return *this;
}

String& String::operator=(String&& rv) noexcept
{
    dealloc();
    size = rv.size;
    data = rv.data;
    return *this;
}

String& String::operator=(const char* str)
{
    dealloc();
    *this = String(get_size(str));
    copy(str);
    return *this;
}

const String operator+(const String& s, const String& s1)
{
    String ret = s;
    ret += s1;
    return ret;
}

String& String::operator+=(const String& rhs)
{
    String s = *this;
    dealloc();
    size = s.size + rhs.size;
    alloc(size);
    copy(s);

    for (unsigned int i = s.size, j = 0; i < s.size + rhs.size, j != rhs.size; i++, j++)
    {
        data[i] = rhs[j];
    }

    return *this;
}

String& String::operator+=(const char* str)
{
    String s = *this;
    dealloc();
    size = s.size + get_size(str);
    alloc(size);
    copy(s);

    for (unsigned int i = s.size, j = 0; i < size, str[j] != '\0'; i++, j++)
    {
        data[i] = str[j];
    }

    return *this;
}

const String operator+(const String& s, const char* str)
{
    String ret = s;
    ret += str;
    return ret;
}

char& String::operator[](size_t indx) const
{
    if (indx < size)
    {
        return data[indx];
    }
    else
    {
        throw std::out_of_range("out of range");
    }
}

bool String::operator<(const String& s) const
{
    int i = 0;

    for (unsigned i = 0; i < size && i < s.size; i++)
    {
        if (data[i] < s.data[i]) return true;
        else if (data[i] > s.data[i]) return true;
    }

    if (size < s.size) return true;
    return false;
}

bool String::operator>(const String& s) const
{
    return !(*this < s);
}

bool String::operator==(const String& s) const
{
    return !(*this < s || *this > s);
}

bool String::operator<(const char* str) const
{
    int i = 0;
    for (unsigned i = 0; i < size && i < get_size(str); i++)
    {
        if (data[i] < str[i]) return true;
        else if (data[i] > str[i]) return false;
    }

    if (size < get_size(str)) return true;
    return false;
}

bool String::operator>(const char* str) const
{
    return !(*this < str);
}

bool String::operator==(const char* str) const
{
    return !(*this < str || *this > str);
}

String& String::operator++()
{
    for (unsigned int i = 0; i < size; i++)
    {
        data[i]++;
    }

    return *this;
}

String& String::operator--()
{
    for (unsigned int i = 0; i < size; i++)
    {
        if (data[i])
        {
            --data[i];
        }
    }

    return *this;
}

std::ostream& operator<<(std::ostream& os, const String& s)
{
    for (unsigned int i = 0; i < s.size; i++)
    {
        os << s.data[i];
    }

    return os;
}