C++

Forum

 
Help neeeeded fasttttrt... urgent

boazgeorge (42)
Please help me These are the errors that i get
1>c:\users\digit_string.h(37): error C2143: syntax error : missing ',' before ':'
1>c:\users\main.cpp(47): error C2664: 'digit_string::digit_string(const WCS_String &)' : cannot convert parameter 1 from 'const char [8]' to 'const WCS_String &'
1>          Reason: cannot convert from 'const char [8]' to 'const WCS_String'
1>          Constructor for class 'WCS_String' is declared 'explicit'
1>c:\users\main.cpp(52): error C2664: 'digit_string::digit_string(const WCS_String &)' : cannot convert parameter 1 from 'const char [8]' to 'const WCS_String &'
1>          Reason: cannot convert from 'const char [8]' to 'const WCS_String'
1>          Constructor for class 'WCS_String' is declared 'explicit'


These are my codes:
digit_string.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
#ifndef DIGIT_STRING_H
#define 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 : s ) if( !std::isdigit(c) )
                 throw std::domain_error( "non numeral in string '" + s + "'" ) ;
           return true ;
       }
};

#endif

main.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
#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' ; }
	};


Please help i need your helpp... very fast... asap
boazgeorge (42)
WCS_String.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
 
#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 (42)
anyone please?
boazgeorge (42)
Friends?
Zhuge (4664)
On lines 47 and 52 of main, you are trying to construct digit strings with C-style string literals (using the "") but you have no constructor defined that does that.

Line 37 of the header: what are you trying to do with that for loop? The syntax looks wrong.
boazgeorge (42)
For the for loop I was trying to do like if some one puts wrong digit it would loop back again. Can u tell me how and what to change
boazgeorge (42)
Also how to fix the loop.
Topic archived. No new replies allowed.