Smart_ptr are useful in C++ for auto-manage of memory, this article introduce scoped_ptr in chrome source code.

Scopers help you manage ownership of a pointer, helping you easily manage the a pointer within a scope, and automatically destroying the pointer at the end of a scope.

Auto management of ownership

// scoped_ptr<T>
     scoped_ptr<Foo> foo(new Foo("wee"));
}  // foo goes out of scope, releasing the pointer with it.

    scoped_ptr<Foo> foo;          // No pointer managed.
    foo.reset(new Foo("wee"));    // Now a pointer is managed.
    foo.reset(new Foo("wee2"));   // Foo("wee") was destroyed.
    foo.reset(new Foo("wee3"));   // Foo("wee2") was destroyed.
    foo->Method();                // Foo::Method() called.
    foo.get()->Method();          // Foo::Method() called.
    // SomeFunc takes ownership, foo no longer
                               // manages a pointer.
    foo.reset(new Foo("wee4"));   // foo manages a pointer again.
    foo.reset();       // Foo("wee4") destroyed, foo no longer
                               // manages a pointer.
}  // foo wasn't managing a pointer, so nothing was destroyed.

// scoped_ptr<T[]>
    scoped_ptr<Foo[]> foo(new Foo[100]);
    foo.get()->Method();  // Foo::Method on the 0th element.
    foo[10].Method();     // Foo::Method on the 10th element.

Movable but not copyable

(see detail in Move Constructor)

Here is an example using scoped_ptr:

void TakesOwnership(scoped_ptr<Foo> arg)
    // Do something with arg

scoped_ptr<Foo> CreateFoo()
    // No need for calling Pass() for a temporary return value.
    return scoped_ptr<Foo>(new Foo("new"));

scoped_ptr<Foo> PassThru(scoped_ptr<Foo> arg)
    return arg.Pass();

    scoped_ptr<Foo> ptr(new Foo("yay")); // ptr manages Foo("yay").
    TakesOwnership(ptr.Pass());   // ptr no longer owns Foo("yay").
    scoped_ptr<Foo> ptr2 = CreateFoo();  // ptr2 owns the return Foo.
    scoped_ptr<Foo> ptr3 =        // ptr3 now owns what was in ptr2.
        PassThru(ptr2.Pass());    // ptr2 is correspondingly NULL.


Pass() properly handles upcast in assignment.

// you can assign scoped_ptr<Child> to scoped_ptr<Parent>:
scoped_ptr<Foo> foo(new Foo());
scoped_ptr<FooParent> parent = foo.Pass();
// PassAs<>()
// should be used to upcast return value in return statement:
scoped_ptr<Foo> CreateFoo()
    scoped_ptr<FooChild> result(new FooChild());
    return result.PassAs<Foo>();