CODEWITHSUNDEEP
c++boost
Craig H
Craig H

Reputation: 7989

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

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.

Upvotes: 38

Views: 12418

Answers (6)

Jeff Hardy
Jeff Hardy

Reputation: 7662

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.

Upvotes: 5

Mark Ransom
Mark Ransom

Reputation: 308530

You might be able to fix it by making the Object constructor explicit.

Upvotes: 0

Jitse Niesen
Jitse Niesen

Reputation: 4542

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.

Upvotes: 43

Tobias
Tobias

Reputation: 845

You need to define a copy constructor.

class Object
{
  public:
    Object(const Object& original)
    {
        // Copy original to new object
        // The reason for the const is this should not change the original 
    };

    Object(int& i)
    {
      i = 2;
    }
};

Upvotes: 1

R&#252;diger Hanke
R&#252;diger Hanke

Reputation: 6255

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.

Upvotes: 8

Craig H
Craig H

Reputation: 7989

While I still have no idea why boost make_shared imposes this limitation on me, I have found a way around it. If I pass in a const reference to a pointer of the parameter, I can then change the pointer. Here is the code snippet:

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


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

This one works like a charm. Anyone have any idea why I need to jump through these hoops though? Seems strange for make_shared to impose this limitation on me, even though I agree it is probably a bad idea most of the time.

Upvotes: 0

Related Questions