Assertion Failed

#include <iostream>
#include "global.h"
#include "sString.h"

using namespace std;

int main()
{
	sString test("cave");
	sString cave = test;
	cave = cave.left(3);
	test = test + " twite";
	cout << test << endl;
	cout << cave << endl;
	test.show();
	cave.show();
	test.clear();
	cout << "Test" << test << endl;
	test = "MONGOLTWIT";
	test = test.leftAt(7,2);
	cout << "Test: " << test << endl;
	test = test + " " + cave;
	cout << "Test: " << test << endl;
	cout << "____" << endl;
	test = test.right(5);
	cout << "Test: " << test << endl;
	return 0;
}

#include "sString.h"
#include "global.h"

using namespace std;
// Constructeurs
sString::sString(void)
{
	m_string = NULL;
	m_length = 0;
}

sString::sString(const char *str)
{
	m_string = sscopy(str);
	m_length = sslen(str);
}

sString::sString(const sString &str)
{
	m_string = sscopy(str.m_string);
	m_length = str.m_length;
}

// -------------------------------
//Destructeur

sString::~sString(void)
{
	delete[] m_string;
}

// Copie

char* sString::sscopy(const char *str)
{
	int len = sslen(str);
	char *chr = new char[len+1];

	for (int x=0 ; x < len ; x++)
	{
		chr[x] = str[x];
	}

	chr[len] = '\0';
	return chr;
}

// Longueur



int sString::sslen(const char *str)
{
	int xlen = 0;

	while (str[xlen] != '\0')
		xlen++;

	return xlen;
}


//Affichage

void sString::show()
{
    std::cout << m_string << std::endl;
}


// Operators

sString sString::operator=(const char *str)
{
    delete[] m_string;

    m_string = sscopy(str);
    m_length = sslen(str);

    return *this;
}

sString sString::operator=(const sString &str)
{
    delete[] m_string;

    m_string = sscopy(str.m_string);
    m_length = str.m_length;

    return *this;
}

sString sString::operator+(const char *str)
{
    int taille = m_length + sslen(str);
    char *tmpStr = new char[taille+1];

    for (int x=0 ; x < sslen(m_string) ; x++)
    {
        tmpStr[x] = m_string[x];
    }

    for (int i=m_length ; i < taille ; i++)
    {
        tmpStr[i] = str[i - m_length];
    }
    tmpStr[taille] = '\0';
    sString result(tmpStr);
    delete[] tmpStr;
    return result;
}

sString sString::operator+(const sString &str)
{
    int taille = m_length + str.m_length;
    char *tmpStr = new char[taille+1];

    for (int x=0 ; x < sslen(m_string) ; x++)
    {
        tmpStr[x] = m_string[x];
    }

    for (int i=m_length ; i < taille ; i++)
    {
        tmpStr[i] = str.m_string[i - m_length];
    }
    tmpStr[taille] = '\0';
    sString result(tmpStr);
    delete[] tmpStr;
    return result;
}

char* sString::getStr()
{
    return m_string;
}

void sString::clear()
{
    m_string = "";
    m_length = 0;
}

sString sString::left(int len)
{
	if (len > sslen(m_string))
	{
		sString result = "ERROR: OVERFLOW (len > totallength)";
		return result;
	}
    char *tmpStr = new char[len+1];
    for (int i = 0; i < len; i++)
    {
        tmpStr[i] = m_string[i];
    }
    tmpStr[len] = '\0';

    sString result(tmpStr);
    delete[] tmpStr;
    return result;
}

sString sString::leftAt(int len, int pos)
{
	int taille = sslen(m_string);
	if (pos + len > taille)
	{
		sString result = "ERROR: OVERFLOW (length + position > totallength)";
		return result;
	}

    char *tmpStr = new char[taille - len + 1];
    for (int i = pos; i-pos < len; i++)
    {
        tmpStr[i-pos] = m_string[i];
    }
    tmpStr[taille - len + pos] = '\0';

    sString result(tmpStr);
    delete[] tmpStr;
    return result;
}

sString sString::right(int len)
{
	int x = 0;
	int i = 0;
	int taille = sslen(m_string);
    char *tmpStr = new char[len+1];
    for (i = taille - len; i < taille; i++)
    {
        tmpStr[x] = m_string[i];
        x++;
    }
    tmpStr[len] = '\0';

    sString result(tmpStr);
    delete[] tmpStr;
    return result;
}

ostream &operator<<( ostream &out, sString &str )
{
    out << str.getStr();
    return out;
}