从unique_ptr初始化unique_ptr const引用

Question

I initialized an unique_ptr with an Object. As i want to pass a reference of it to a function and don't let the function to change the object contents, I have to pass unique_ptr<const MyObject>& to it. But gcc 5.4 doesn't let me to initialize unique_ptr<const MyObject>& from uinque_ptr<MyObject> .

Example Code:

class Foo{public int x;};
unique_ptr<Foo> foo(new Foo());
foo->x = 5;

// User shouldn't be able to touch bar contents.
unique_ptr<const Foo>& bar = foo;

C++ error:

error: invalid initialization of reference of type ‘std::unique_ptr<const Foo>&’ from expression of type ‘std::unique_ptr<Foo>’

So is there any reasonable way to do it?

Answer 1

There are two issues:

• How to constify the referent of a unique_ptr .
• How to pass a non-owning pointer to a function.

The reasonable way to pass a non-owning pointer is to pass a raw pointer:

some_function( my_unique_ptr.get() );

Or if it can't be null then you can dereference the pointer and pass a reference,

some_function( *my_unique_ptr )

This means that the constification is pretty much irrelevant to the main issue, but still, here's how to do that also:

unique_ptr<Foo>         p{ new Foo() };
unique_ptr<const Foo>   q{ move( p ) };    // Moves ownership!

Answer 2

A valid answer has already been posted.

I just want to provide some additional ideas for the case that the pointer could be empty.

Idea 1: Wrap the pointer into a std::shared_ptr with empty deleter:

#include <iostream>
#include <memory>

struct Foo{ int x; };

void Fun( std::shared_ptr<const Foo> p ) {
    if( p )     
        std::cout << "p.x: " << p->x << std::endl;
    //won't compile:
    //delete p;
}

int main(){
    std::unique_ptr<Foo> foo(new Foo());
    foo->x = 5;

    std::shared_ptr<const Foo> bar( foo.get(), []( const Foo* ){} );
    Fun( bar );

    return 0;
}

Live Demo

Idea 2: Use boost::optional to pass a reference but still allow it to be empty. Unfortunately this doesn't work with std::optional because std::optional doesn't allow reference arguments.

#include <iostream>
#include <memory>
#include <boost/optional.hpp>

struct Foo{ int x; };

using OptionalFooConstRef = boost::optional<Foo const&>;

void Fun( OptionalFooConstRef p ){
    if( p )
        std::cout << "p.x: " << p->x << std::endl;
    else
        std::cout << "no foo\n";
    //won't compile:
    //delete p;
}

int main(){
    std::unique_ptr<Foo> foo(new Foo());
    foo->x = 5;

    Fun( foo ? OptionalFooConstRef( *foo ) : boost::none );

    std::unique_ptr<Foo> nofoo;
    Fun( nofoo ? OptionalFooConstRef( *nofoo ) : boost::none );

    return 0;
}

Live Demo

Conclusion:

I would prefer boost::optional because it better expresses the intention.