should I call void constructor to reset object in move semantic?

Question

As I know,
the purpose of void constructor is to reset all the element from choas state to proper new-born state.
and this statment is quite accruate for me to do it after steal data from rvalue referance.
but it seems to be a invild use for direct call to void constructor,and placement-new not work for this.

so,

should I call void constructor to reset object in move semantic?
should I write reset() and invoke() like this one?
what should void constructor do?
is my string inplmentation good enough?

#include <cstring>


class STR_imp
{
    char* cstr;

    static size_t getSize(const char* incstr)
    {
        return std::strlen(incstr)+1;
    };
    STR_imp& fillBy(const char* incstr)
    {
        for(int i=0,size=getSize(incstr);i<size;i++)
            this->cstr[i]=incstr[i];
        return *this;
    };
    STR_imp& reset()
    {
        this->cstr=nullptr;
        return *this;
    };
    STR_imp& invoke()
    {
        if(this->cstr!=nullptr)
            delete[] this->cstr;
        return *this;
    };

    public:
        STR_imp():cstr(nullptr)
        {};
        ~STR_imp()
        {this->invoke().reset();};

        STR_imp(const char* const& incstr);//splited for reading
        STR_imp(char*&& incstr):cstr(incstr)
        {
            incstr=nullptr;
        };
        STR_imp(const STR_imp& instr);//splited for reading
        STR_imp(STR_imp&& instr):cstr(instr.cstr)
        {
            instr.reset();
        };
        STR_imp& operator= (const char* const& incstr);//splited for reading
        STR_imp& operator= (char*&& incstr)
        {
            this->invoke();
            this->cstr=incstr;
            incstr=nullptr;
            return *this;
        };
        STR_imp& operator= (const STR_imp& instr);//splited for reading
        STR_imp& operator= (STR_imp&& instr)
        {
            this->invoke();
            this->cstr=instr.cstr;
            instr.reset();
            return *this;
        };
        char* operator() ()
        {
            return this->cstr;
        };
};
STR_imp::STR_imp(const char* const& incstr):cstr(new char[getSize(incstr)])
{
    this->fillBy(incstr);
};
STR_imp::STR_imp(const STR_imp& instr):cstr(new char[getSize(instr.cstr)])
{
    this->fillBy(instr.cstr);
};
STR_imp& STR_imp::operator= (const char* const& incstr)
{
    this->invoke();
    this->cstr=new char[getSize(incstr)];
    this->fillBy(incstr);
    return *this;
};
STR_imp& STR_imp::operator= (const STR_imp& instr)
{
    this->invoke();
    this->cstr=new char[getSize(instr.cstr)];
    this->fillBy(instr.cstr);
    return *this;
};

You're over-engineering; 3/4 of your code isn't needed. It is unclear what `invoke()` does or even should do. *Invoke* is a synonym for *call* or *use*. — rustyx, Apr 22 '20 at 19:30
What's with passing a `char` pointer by const reference & by rvalue reference? A single `STR_imp(const char *);` is enough. Also, you probably shouldn't be adding any overloads to `operator=` other than the copy/move. You'll still be able to assign `char` pointers to your object because of the non-`explicit` constuctor. — HolyBlackCat, Apr 22 '20 at 19:35
@AsteroidsWithWings From context, I'm fairly certain OP is referring to the default constructor. — cdhowie, Apr 22 '20 at 19:41
All those `this->`s are distracting. You don't need them, and they just clutter the code. — Pete Becker, Apr 22 '20 at 21:53
`STR_imp::fillBy` can be implemented much more simply by just calling `strcpy`. — Pete Becker, Apr 22 '20 at 21:54
@Asteroids can you tell me what name I should specify to them? — AiDSl, Apr 23 '20 at 17:53
@HolyBlackCat I was thought that it might sometimes take kind of factory function(which is bad practice that I known) that produce pointer that should be manage,to doing this,I could only get them as rvalue referance pointer — AiDSl, Apr 23 '20 at 17:57
@AsteroidsWithWings the "void constructor" I was talk about...maybe it should be call "void argument constructor"? — AiDSl, Apr 23 '20 at 18:00
@AsteroidsWithWings but what is the name of automatic generated constructor?like "STR_imp()=default;" — AiDSl, Apr 23 '20 at 18:16
That is a defaulted default constructor. I know. Silly language. — Asteroids With Wings, Apr 23 '20 at 18:46

cdhowie · Accepted Answer · 2020-04-22T19:36:55.137

I'm only going to address the question about move semantics here, because you should only ask one question at a time.

The move constructor can generally leave the object in whatever state it wants, as long as you document the postconditions so that users of the class know what to expect.

For example, many classes in the C++ standard library declare that a moved-from object is in an unspecified but valid state. This means that you can't make any assumptions about the state of the object, but you can ask the object what its state is or you can manually reset it to a clear state. (The "proper" way to say this is that you can only call methods of the object that have no preconditions.)

I believe this route was chosen because the most efficient way to implement move semantics is simply to swap the values of the target and source objects. Usually this is fine because in many scenarios, the source object is either going to be destroyed right away or manually cleared.

The way you'd typically do this is to:

Implement a valid swap() method:

void STR_imp::swap(STR_imp & other) {
  std::swap(cstr, other.cstr);
}

On move-assignment, just swap:

STR_imp& STR_imp::operator=(STR_imp&& instr) {
  swap(instr);
  return *this;
}

On move-construction, construct the default state and then swap:

STR_imp::STR_imp(STR_imp&& instr) : STR_imp{} {
  swap(instr);
}

This pattern has multiple advantages. The biggest advantage is that it's really hard to get wrong if your swap() method works correctly. Another advantage is that it forces you to support swapping, which is useful on its own in many different scenarios.

so,self answering here(might be wrong): 1,3.the constructor I was talk about should only apply to object in invalid state which only in case of non-constructed object,and in that object life time,it should always valid but could be unspecified . — AiDSl, Apr 23 '20 at 18:14

score 0 · Answer 2 · answered Apr 22 '20 at 19:29

A destructor in C++ destroys your object as its name states meaning that after calling it the underlying memory of your object has been freed. This also means that you cannot access it anymore since its not present in your application.

If you want to reset an object, you can just call your reset function, which will clear the data the way you want. If you want a clean copy of your object, you can use the move assignment operator and then call reset on the copied object.

Note that setting cstr to nullptr doesn't free the memory. Here is what you should do instead:

~STR_imp() { delete cstr; }

STR_imp& reset()
{
  delete cstr;
  cstr = nullptr;
  return *this;
}

ok,but because it is array of char,so it should be delete[] cstr right? — AiDSl, Apr 23 '20 at 18:21

should I call void constructor to reset object in move semantic?

2 Answers2