Re: Is this String class properly implemented?
On 18 Apr., 13:31, kevintse.on...@gmail.com wrote:
I am new to the C++ language, I implement this String class just for
practising.
Ok.
class String{
private:
wchar_t* value;
int size;
The typical approach would be to use two integers (of some type like
std::size_t). The 2nd integer -- usually called "capacity" -- stores
the size of the array whereas "size" (the logical length of the
string) may be smaller. I didn't check your implementation for
operator+= but you usually don't want to allocate a new character
array every time you add a new character to the string.
You also may want to throw out some member functions and replace them
with free functions if appropriate. std::string is an example of a
"bloated super class".
public:
String(String& s);
Your copy constructor doesn't take a referece-to-const?
operator const wchar_t* () const {
return value;
}
This is dangerous since this allows *implicit* conversion to a pointer
that points to memory that is *managed* by the string object. If the
string object dies and deletes the char array you basically have an
invalid pointer. Example:
String foo();
void bar() {
wchar_t * invalid = foo();
// accessing "invalid" invokes undefined behaviour
}
This is why std::string has a c_str() member function for this as
opposed to an implicit conversion operator.
Also: Consider making some constructors explicit. Check your textbook
on explicit constructors and conversion.
~String(){
size = 0;
delete [] value;
}
"size = 0;" is pretty much useless here.
//these two functions cannot be properly implemented usin=
g
// plain pointers, an Array class is required?
String** split(const wchar_t& c) const;
String** split(const String& s) const;
It's not clear from the signature and the functions' names what it is
exactly the functions do and return. Do you intent do create String
objects dynamically as well as an array of String pointers? Please
don't. Instead, write a *free* function (not a member function) that
does the splitting. This free function could return a vector<String>
object or it could be a function template that takes an "output
iterator" like this:
template<typename OutIter>
void split(String const& str, wchar_t at, OutIter oiter) {
...
*oiter = some_substring;
++oiter;
...
}
which allows you to write
void foo(String const& x) {
vector<String> blah;
split(x,'.',back_inserter(blah));
}
See documentation for the standard header file <iterator>.
( http://www.cplusplus.com/reference/std/iterator/ )
String trim();
String trimLeft();
String trimRight();
....are just three examples that could have been free functions
instead. Also, since you seem to be creating a new String object for
the result as return value you seem to have forgotten 'const'
qualifiers.
String operator=(String& str);
Your copy assignment doesn't take a reference-to-const String?
#include "String.h"
String::String(){
size = 0;
value = new wchar_t[1]; //one wchar_t to store the term=
inating null
value[0] = '\0';
}
You might want to delay the allocation until you need to return a
wchar_t pointer to a zero terminated string. This should make
creating empty strings faster.
[snipped a whole lot of code I'm too lazy to go through]
Cheers!
SG