Question

I’m not an C++ expert and still do not have a great intuitive grasp of how things works. I think this is a simple question. I am having trouble passing objects with state to other objects. I’d prefer to avoid passing pointers or references, since once the initialized objects are setup, I call them millions of times in a tight loop. I think I’m dong something like a Command pattern. Here’s the core of the problem. My header code is something like:

class ObjectWithState {
public:
  ObjectWithState(int state) { // This constructor creates the problem!
    state_ = state;       // everyting works with no constructor.
  }
private:
  int state_;
};

class TakesObject {
public:
  TakesObject(ObjectWithState obj) {
    obj_ = obj;
  }
private:
  ObjectWithState obj_;
};

My main() functions looks like:

int main () {
  ObjectWithState some_object(1);
  TakesObject takes_object(some_object);
  return 0
}

I get the following error (g++):

test.h: In constructor 'TakesObject::TakesObject(ObjectWithState)':
test.h:14: error: no matching function for call to 'ObjectWithState::ObjectWithState()'
test.h:5: note: candidates are: ObjectWithState::ObjectWithState(int)
test.h:3: note:                 ObjectWithState::ObjectWithState(const ObjectWithState&)

Simple answer?

I not sure if this has to do with copy constructors. If so, I’m trying to find a solution that keeps the class definition of ObjectWithState very clean and short. Users of this library will be defining lots of small functions like that which will be used by TakesObject function. Ideally programmers of the ObjectsWithState just need to focus on implementing a simple object. Perhaps I’m going astray…

Answer 1

What you may want to do is use the member initialisation syntax:

class TakesObject {
public:
  TakesObject(ObjectWithState obj): obj_(obj) {
  }
private:
  ObjectWithState obj_;
};

In your posted code, the TakesObject constructor will first try to construct a new ObjectWithState with its default constructor, then call the assignment operator to copy the passed-in obj to obj_. The above example constructs the obj_ directly using its copy constructor.

You will also need to define a copy constructor for your ObjectWithState class, too:

class ObjectWithState {
public:
  ObjectWithState(int state) {
    state_ = state;
  }
  ObjectWithState(const ObjectWithState &rhs) {
    state_ = rhs.state_;
  }
private:
  int state_;
};

If you omit all constructors from your class declaration, then the compiler supplies a default and a copy constructor for you. If you declare any constructors, then the compiler supplies no default or copy constructor, so you must implement your own.