ansaurus

Question

Why can't I assign a scalar value to a class using shorthand, but instead declare it first, then set its value?

Answer 1

+15 A:

Your problem is that ustring a = "test" actually invokes the constructor, not the assignment operator. yay, welcome to c++ :)

You'll need to define yourself both a default constructor and one that takes a const char*, because once you define a constructor, you need to define all your constructors.

A few other things:

pass your input ustring by reference
pass const char * instead of char[] (you don't modify the input and char* is more common)
sizeof isn't doing what you think it's doing, it doesn't work properly for array parameters. It is returning you sizeof(char*), not sizeof(array).
return reference to this from your operators.
you can use vector<int> values; to manage all your memory for you.
encode() should probably return a string. With string:
- it manages its own memory, so the caller doesn't need to free or delete it.
- you can use s.append(c); instead of using realloc.
- you can use printf("%s", s.c_str());, but in c++ you usually use cout << s;
consider defining a copy constructor as well.

Like this:

class ustring {
 public:
  // Default constructor, allows you to create your class with no arguments.
  ustring() { ...; }
  // Allows you to create your class from string literals.
  ustring(const char *input) { ...; }
  // Copy constructor, allows you to create your class from other instances.
  ustring(const ustring &input) { ...; }

  // Assignment operators.
  ustring &operator=(const ustring &input) { ...; return *this; }
  ustring &operator=(const char *input) { ...; return *this; }
};

int main() {
  ustring s, t;  // invokes default constructor.
  s = t;         // invokes ustring assignment op.
  s = "test";    // invokes const char* assignment op.
  ustring u = "test";  // invokes const char* constructor.
  ustring v("test");   // invokes const char* constructor.
  ustring x(u);  // invokes copy constructor.
}

If this is c++, why are you doing all this malloc/realloc stuff? I haven't fully parsed that code, but I'd imagine there's a simpler way... see the comment about using vector.

As @Michael Aaron Safyan mentioned in the comments, if you do any memory allocation for the ustring class, you will want to deallocate it in the destructor. However, I think by switching to memory managed containers - vector & string - you'll avoid any of your own memory management and can avoid writing a destructor.

Stephen 2010-05-02 02:31:40

@Stephen, don't forget the destructor! Especially since the OP is doing memory allocation and needs to deallocate it in his destructor. You might also want to suggest swap as an easy, clean way to perform assignment.

Michael Aaron Safyan 2010-05-02 07:59:19

Thank you very much for your answer; it was very helpful and I'm now giving your advice a go. However, when you say that "encode() should probably return a string", I think that returning a char* is better because you can then use the UTF-8 string as follows: printf("%s\n", mystring.encode());

Delan Azabani 2010-05-02 08:36:25

Also, another dilemma... if I 'pass const char * instead of char[]', then I won't be able to sizeof() to get the string length. If so, should I just stop at null?

Delan Azabani 2010-05-02 08:56:14

@Michael Aaron Safyan, @Delan Azabani : edited my answer in response to your comments. Thanks!

Stephen 2010-05-02 14:39:37

@Delan: If `encode` returned a `std::string`, you could do `printf("%s\n", mystring.encode().c_str())`. Hardly a big problem. Plus it saves the user from having to keep track of the ownership semantics of the encoded string. Don't use `char*`. You're making things harder for yourself and the user of your class.

jalf 2010-05-02 14:50:22

@Delan, since UTF-8 does not allow the embedding of NULs, there's no reason why you couldn't store a UTF-8 string in an std::string. In fact, the encoding of std::string is unspecified... it could, on some systems, be interpreted as storing a UTF-8 string.

Michael Aaron Safyan 2010-05-02 15:45:57

Answer 2

+1 A:

These are two operations:

ustring a; // construct a new object using constructor
a = "test"; // assign value to object using operator=

This is one operation:

ustring a = "test"; // construct with a value, aka value-intialization

In the interest of runtime efficiency and allowing semantic freedom, C++ does not extrapolate the default constructor ustring::ustring() and the assignment operator ustring::operator=(const char*) into a constructor ustring::ustring(const char *).

But, for most reasonable string classes, this will work:

ustring::ustring(const char *str)
 : /* initialize ustring::ustring() does */ {
    /* do whatever ustring::ustring() does */
    *this = str; // assign value.
}

It is better to call the assignment operator from the constructor than to attempt it the other way around.

Of course, you can probably improve efficiency by considering the length of the given string while performing initialization.

Potatoswatter 2010-05-02 03:04:33

ansaurus

tags:

views:

answers:

Why can't I assign a scalar value to a class using shorthand, but instead declare it first, then set its value?

related questions