boost make_shared takes in a const reference. Any way to get around this?

Question

I am using boost shared pointers in my program, and I have a class that takes as a parameters a reference to another object. The problem I am running into is the make_shared function requires all parameters to be a const reference, and I get compile errors if my class's constructor doesn't allow const reference parameters to be passed in.

Does anyone know the reason behind this? Also, is there anything I can do to get around this?

code example of what is giving me problems:

class Object
{
  public:
    Object(int& i)
    {
      i = 2;
    }
};


int main(int argc, char *argv[])
{
  int i = 0;
  boost::shared_ptr<Object> obj = boost::make_shared<Object>(i);
  return 1;
}

This results in a compiler error that states the following

:make_shared.hpp:185: error: no matching function for call to `Object::Object(const int&)' note: candidates are: Object::Object(const Object&) note: Object::Object(int&)

If the parameter to Objects constructor is a const int, this works. I am curious as to why make_shared behaves this way.

Answer 1

http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/make_shared.html says: "If you need to pass a non-const reference to a constructor of T, you may do so by wrapping the parameter in a call to boost::ref." Other text on that page seems to support Rüdiger Hanke's answer.

Answer 2

Can't speak for the authors of he function, but ... you've got to make a choice. If the function would use a non-const reference, then you couldn't pass const objects to constructors that take const references.

In my experience, constructors taking const references are far more common than constructors taking mutable references.

Constructors can have n parameters, so you can't just provide a single overload, but have to take into account any combination of const/non-const which results in an exponential explosion of overloads you'd need if you'd want to provide overloads for all of them. C++0x and perfect forwarding should provide a solution for this issue I think.

Answer 3

Until rvalue references (see the section titled "the forwarding problem") arrive in C++0x, perfect forwarding is next to impossible. make_shared just does the best it can with what it's given.