strings.cpp

This a Vector Class overloading operator >>,<<,+,-,*,=,! 2 vector

// Strings.cpp: implementation of the Strings class.
//
//////////////////////////////////////////////////////////////////////
#include <iostream.h>
#include <iomanip.h>
#include "strings.h"
#include <string.h>
#include <assert.h>
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Strings::Strings(const char *S)
{
	cout << "Conversion constructor: " << S << endl;
	Length = strlen(S);
	Ptr = new char[Length + 1];
	assert(Ptr != 0);
	strcpy(Ptr, S);
}

Strings::Strings(const Strings &Copy)
{
	cout << "Copy constructor: " << Copy.Ptr << endl;
	Length = Copy.Length;
	Ptr = new char[Length + 1];
	assert(Ptr != 0);
	strcpy(Ptr, Copy.Ptr);
}

//Destructor
Strings::~Strings()
{
	cout << "Destructor: " << Ptr << endl;
	delete [] Ptr;
}

Strings &Strings::operator=(const Strings &Right)
{
	cout << "operator= called" << endl;
	if (&Right != this)
	{
		delete [] Ptr;
		Length = Right.Length;
		Ptr = new char[Length + 1];
		assert(Ptr != 0);
		strcpy(Ptr, Right.Ptr);
	}
	else
		cout<<"Attempted assignment of a Strings 
									to itself" << endl;
	return *this;
}

Strings &Strings::operator+=(const Strings &Right)
{
	char *TempPtr = Ptr;
	Length += Right.Length;
	Ptr = new char[Length + 1];
	assert(Ptr != 0);
	strcpy(Ptr, TempPtr);
	strcat(Ptr, Right.Ptr);
	delete [] TempPtr;
	return *this;
}

int Strings::operator!() const
{
	return Length == 0;
}

int Strings::operator==(const Strings &Right) const
{
	return strcmp(Ptr, Right.Ptr) == 0;
}

int Strings::operator!=(const Strings &Right) const
{
	return strcmp(Ptr, Right.Ptr) != 0;
}

int Strings::operator<(const Strings &Right) const
{
	return strcmp(Ptr, Right.Ptr) < 0;
}

int Strings::operator>(const Strings &Right) const
{
	return strcmp(Ptr, Right.Ptr) > 0;
}

int Strings::operator>=(const Strings &Right) const
{
	return strcmp(Ptr, Right.Ptr) >= 0;
}

int Strings::operator<=(const Strings &Right) const
{
	return strcmp(Ptr, Right.Ptr) <= 0;
}

char &Strings::operator[](int Subscript)
{
	assert(Subscript >= 0 && Subscript < Length);
	return Ptr[Subscript];
}

Strings &Strings::operator()(int Index, int SubLength)
{
	assert(Index >= 0 && Index < Length 
								&& SubLength >= 0);
	Strings *SubPtr = new Strings;
	assert(SubPtr != 0);
	if ((SubLength == 0)||(Index + SubLength > Length))
		SubPtr->Length = Length - Index + 1;
	else
		SubPtr->Length = SubLength + 1;
	delete SubPtr->Ptr;
	SubPtr->Ptr = new char[SubPtr->Length];
	assert(SubPtr->Ptr != 0);
	strncpy(SubPtr->Ptr, &Ptr[Index], SubPtr->Length);
	SubPtr->Ptr[SubPtr->Length] = '\0';
	return *SubPtr;
}

int Strings::GetLength() const
{
	return Length;
}
ostream &operator<<(ostream &Output, const Strings &S)
{
	Output << S.Ptr;
	return Output;
}

istream &operator>>(istream &Input, Strings &S)
{
	char Temp[100];
	Input >> setw(100) >> Temp;
	S = Temp;
	return Input;
}