Guys need a fast help -- i have to submit my assignment at midnight

[boazgeorge]

What should i change to make this both compile??.. one of the errors in my digit_string.h is not the right loop.. please help me by giving the right loop.. and also on my main.. is the part where exception is there correct..

I tried my best.. but compiling not working.. need your big help friend.. wont forget anytime..

The assignment is :
DigitString – This class will allow only digits to be stored. Usage of other types of characters will cause an exception to be thrown.
All error checking (bounds checking of indices, etc.) must be handled as exceptions (try, throw, catch). Your test program must demonstrate that all exception tests work.

Please verify if all is right...

Please help.. i am trusting on u guys

main.cpp

#include <iostream>

using namespace std;

#include "UpperCaseString.h"
#include "digit_string.h"

void main ()
	{
	WCS_String			S1 ("abcdef");
	UpperCaseString		U1;
	UpperCaseString		U2 (U1);
	UpperCaseString		U3 (S1);
	UpperCaseString		U4 (WCS_String ("abcd"));
	digit_string		s;

	U3.Display ();
	cout << endl;
//	U2.ToLower ();

	U2 = U3;
	U2 = S1;	// U2 = UpperCaseString (S1);
//	U2 = "abcd";

	if (U2.Compare (U3) == 0)
			cout << "Same" << endl;
		else
			cout << "Different" << endl;

	if (U2.Compare (S1) == 0)
			cout << "Same" << endl;
		else
			cout << "Different" << endl;

//	U2 [1] = 'a';
	U2.Display ();
	cout << endl;

	U2.Concat (S1);
	U2.Display ();
	cout << endl;

	U2.SetAt ('x', 1);
	U2.Display ();
	cout << endl;

	try { digit_string s( "1234X67" ) ; std::cout << s <<  ": ok\n" ; }
    catch( const std::exception& e ) { std::cerr << "error: " << e.what() << '\n' ; }

    try
    {
        digit_string s( "1234567" ) ; std::cout << s <<  ": ok\n" ;
        s.SetAt( '9', 3 ) ; std::cout << s <<  ": ok\n" ;
        s.SetAt( '@', 3 ) ; std::cout << s <<  ": ok\n" ;
    }
    catch( const std::exception& e ) { std::cerr << "error: " << e.what() << '\n' ; }
	};

digit_string.h

#include <iostream>
#include <string>
#include <cctype>
#include <stdexcept>
#include "WCS_String.h"

using namespace std;
struct digit_string: public WCS_String
{
digit_string();   
digit_string( const WCS_String & s ) : str(s) { are_digits(str) ; }
~digit_string();

bool SetAt( char c, std::size_t pos )
    {
        if( !std::isdigit(c) )
            throw std::domain_error( WCS_String("non numeral character '") + c + "'" ) ;
        else str.SetAt(pos, c); // std::string will throw if pos is out of range
        return true ;
    }

    digit_string operator= ( const WCS_String& s ) { if( are_digits(s) ) str = s ; return *this ; }

		


    friend inline std::ostream& operator<< ( std::ostream& stm, const digit_string& s )
    { return stm << s.str ; }

    private:
      WCS_String str ;
       bool are_digits( const WCS_String& s )
       {
           for( char c = 0; c < strlen(s); ++c) if( !std::isdigit(c) )
                 throw std::domain_error( "non numeral in string '" + s + "'" ) ;
           return true ;
       }
};

#endif 

[boazgeorge]

WCS_String.h

#ifndef WCS_STRING_H
#define WCS_STRING_H

#include <cctype>
#include <cstring>
#include <iostream>

using namespace std;

#pragma warning (disable:4996)

class WCS_String
	{
//************* Exceptions *****
	public:
		enum		Exceptions	{IndexOutOfBounds};
//************* Method Prototypes *****
	public:
		explicit				WCS_String				(const char * = "")				throw (...);
								WCS_String				(const WCS_String &)			throw (...);
		virtual					~WCS_String				()								throw ();
				int				Compare					(const WCS_String &)	const	throw ();
				int				Compare					(const char *)			const	throw ();
				WCS_String &	Concat					(const WCS_String &)			throw (...);
				WCS_String &	Concat					(const char *)					throw (...);
				WCS_String &	Copy					(const WCS_String &)			throw (...);
				WCS_String &	Copy					(const char *)					throw (...);
				ostream &		Display					(ostream & = cout)		const;
				bool			GetAt					(char &, int)			const	throw (...);
				bool			IsEmpty					()						const	throw ();
				size_t			Length					()						const	throw ();
				istream &		Read					(istream & = cin)				throw (...);
		static	char			ReadChar				(istream & = cin)				throw ();
				bool			SetAt					(char, int)						throw (...);

				WCS_String &	ToLower					()								throw ();
				WCS_String &	ToUpper					()								throw ();
								operator bool			()						const	throw ();
								operator const char *	()						const	throw ();
				WCS_String &	operator =				(const WCS_String &)			throw (...);
				WCS_String &	operator =				(const char *)					throw (...);
				bool			operator <				(const WCS_String &)	const	throw ();
				bool			operator <				(const char *)			const	throw ();
				bool			operator <=				(const WCS_String &)	const	throw ();
				bool			operator <=				(const char *)			const	throw ();
				bool			operator ==				(const WCS_String &)	const	throw ();
				bool			operator ==				(const char *)			const	throw ();
				bool			operator >=				(const WCS_String &)	const	throw ();
				bool			operator >=				(const char *)			const	throw ();
				bool			operator >				(const WCS_String &)	const	throw ();
				bool			operator >				(const char *)			const	throw ();
				bool			operator !=				(const WCS_String &)	const	throw ();
				bool			operator !=				(const char *)			const	throw ();
				WCS_String		operator &				(const WCS_String &)	const	throw (...);
				WCS_String		operator &				(const char *)			const	throw (...);
				WCS_String &	operator &=				(const WCS_String &)			throw (...);
				WCS_String &	operator &=				(const char *)					throw (...);
				char &			operator []				(int)							throw (...);
				char			operator []				(int)					const	throw (...);
	private:
				bool			IsValidSubscript		(int)					const	throw ();
				void			LocalCheckAndCopy		(const char *)					throw (...);
				WCS_String &	LocalConcat				(const char *)					throw (...);
				void			LocalCopy				(const char *)					throw (...);
				WCS_String		NewConcat				(const char *)			const	throw (...);
								operator char *			()						const	throw ();
//************* Properties *****
	private:
				char *	pChar;
				size_t	CharCount;
				size_t	MaxSize;
	};

//************* Method Definitions *****

inline WCS_String::WCS_String (const char * p): CharCount (0), MaxSize (0), pChar (0)
	{
	LocalCopy (p);
	}

inline WCS_String::WCS_String (const WCS_String & M)
	{
	LocalCopy (M.pChar);
	}

inline int WCS_String::Compare (const WCS_String & M) const
	{
	return strcmp (pChar, M.pChar);
	}

inline int WCS_String::Compare (const char * p) const
	{
	return strcmp (pChar, p);
	}

inline WCS_String & WCS_String::Concat (const WCS_String & M)
	{
	return LocalConcat (M.pChar);
	}

inline WCS_String & WCS_String::Concat (const char * p)
	{
	return LocalConcat (p);
	}

inline WCS_String & WCS_String::Copy (const WCS_String & M)
	{
	return *this = M;
	}

inline WCS_String & WCS_String::Copy (const char * p)
	{
	return *this = p;
	}

inline ostream & WCS_String::Display (ostream & out) const
	{
	return out << pChar;
	}

inline bool WCS_String::GetAt (char & c, int i) const
	{
	if (IsValidSubscript (i))
			{
			c = pChar [i];
			return true;
			}
		else
			return false;
	}

inline bool WCS_String::IsEmpty () const
	{
	return Length () == 0;
	}

inline bool WCS_String::IsValidSubscript (int i) const
	{
	return (i >= 0) && (i < static_cast <int> (CharCount));
	}

inline size_t WCS_String::Length () const
	{
	return CharCount;
	}

inline WCS_String WCS_String::NewConcat (const char * p) const
	{
	WCS_String S (*this);
	S.Concat (p);
	return S;
	}

inline WCS_String::operator bool () const
	{
	return Length () > 0;
	}

inline WCS_String::operator const char * () const
	{
	return pChar;
	}

inline WCS_String & WCS_String::operator = (const WCS_String & M)
	{
	if (this != &M)
			LocalCheckAndCopy (M.pChar);
		else;
	return *this;
	}

inline WCS_String & WCS_String::operator = (const char * p)
	{
	LocalCheckAndCopy (p);
	return *this;
	}

inline bool WCS_String::operator <	(const WCS_String & M) const
	{
	return Compare (M) < 0;
	}

inline bool WCS_String::operator <	(const char * p) const
	{
	return Compare (p) < 0;
	}

inline bool operator <	(const char * p, const WCS_String & S)
	{
	return S.Compare (p) > 0;
	}

inline bool WCS_String::operator <=	(const WCS_String & M) const
	{
	return Compare (M) <= 0;
	}

inline bool WCS_String::operator <=	(const char * p) const
	{
	return Compare (p) <= 0;
	}

inline bool operator <=	(const char * p, const WCS_String & S)
	{
	return S.Compare (p) >= 0;
	}

inline bool WCS_String::operator ==	(const WCS_String & M) const
	{
	return Compare (M) == 0;
	}

inline bool WCS_String::operator ==	(const char * p) const
	{
	return Compare (p) == 0;
	}

inline bool operator ==	(const char * p, const WCS_String & S)
	{
	return S.Compare (p) == 0;
	}

inline bool WCS_String::operator >=	(const WCS_String & M) const
	{
	return Compare (M) >= 0;
	}

inline bool WCS_String::operator >=	(const char * p) const
	{
	return Compare (p) >= 0;
	}

inline bool operator >=	(const char * p, const WCS_String & S)
	{
	return S.Compare (p) <= 0;
	}

inline bool WCS_String::operator >	(const WCS_String & M) const
	{
	return Compare (M) > 0;
	}

inline bool WCS_String::operator >	(const char * p) const
	{
	return Compare (p) > 0;
	}

inline bool operator >	(const char * p, const WCS_String & S)
	{
	return S.Compare (p) < 0;
	}

inline bool WCS_String::operator !=	(const WCS_String & M) const
	{
	return Compare (M) != 0;
	}

inline bool WCS_String::operator !=	(const char * p) const
	{
	return Compare (p) != 0;
	}

inline bool operator !=	(const char * p, const WCS_String & S)
	{
	return S.Compare (p) != 0;
	}

inline WCS_String WCS_String::operator & (const WCS_String & M) const
	{
	return NewConcat (M.pChar);
	}

inline WCS_String WCS_String::operator & (const char * p) const
	{
	return NewConcat (p);
	}

inline WCS_String operator & (const char * p, const WCS_String & S)
	{
	WCS_String Temp (p);
	return Temp.Concat (S);
	}

inline WCS_String &	WCS_String::operator &=	(const WCS_String & M)
	{
	return Concat (M);
	}

inline WCS_String &	WCS_String::operator &=	(const char * p)
	{
	return Concat (p);
	}

inline char & WCS_String::operator [] (int i)
	{
	if (IsValidSubscript (i))
			return pChar [i];
		else
			throw IndexOutOfBounds;
	}

inline char WCS_String::operator [] (int i) const
	{
	return (*const_cast <WCS_String *> (this)).operator [] (i);
	}

inline bool WCS_String::SetAt (char c, int i)
	{
	if ((i >= 0) && (i < static_cast <int> (CharCount)))
			{
			pChar [i] = c;
			return true;
			}
		else
			return false;
	}

inline ostream & operator << (ostream & out, const WCS_String & M)
	{
	return M.Display (out);
	}

inline istream & operator >> (istream & in, WCS_String & M)
	{
	return M.Read (in);
	}

#pragma warning (default:4996)

#endif 

[boazgeorge]

Please any one ? Need to be done by midnight

[boazgeorge]

Anyone

[DSLq5Di1]

boazgeorge wrote:

Please help.. i am trusting on u guys

I trust you won't edit and remove your posts once the problem has been solved..?

       bool are_digits( const WCS_String& s )
       {
           for( char c = 0; c < strlen(s); ++c) if( !std::isdigit(c) )
                 throw std::domain_error( "non numeral in string '" + s + "'" ) ;
           return true ;
       }

isdigit() should be testing the characters in s, not the value of c.

[boazgeorge]

Thanks yes u can trust me but still errors are there ):