modernize-replace-auto-ptr¶
This check replaces the uses of the deprecated class std::auto_ptr
by
std::unique_ptr
(introduced in C++11). The transfer of ownership, done
by the copy-constructor and the assignment operator, is changed to match
std::unique_ptr
usage by using explicit calls to std::move()
.
Migration example:
-void take_ownership_fn(std::auto_ptr<int> int_ptr);
+void take_ownership_fn(std::unique_ptr<int> int_ptr);
void f(int x) {
- std::auto_ptr<int> a(new int(x));
- std::auto_ptr<int> b;
+ std::unique_ptr<int> a(new int(x));
+ std::unique_ptr<int> b;
- b = a;
- take_ownership_fn(b);
+ b = std::move(a);
+ take_ownership_fn(std::move(b));
}
Since std::move()
is a library function declared in <utility>
it may be
necessary to add this include. The check will add the include directive when
necessary.
Known Limitations¶
If headers modification is not activated or if a header is not allowed to be changed this check will produce broken code (compilation error), where the headers’ code will stay unchanged while the code using them will be changed.
Client code that declares a reference to an
std::auto_ptr
coming from code that can’t be migrated (such as a header coming from a 3rd party library) will produce a compilation error after migration. This is because the type of the reference will be changed tostd::unique_ptr
but the type returned by the library won’t change, binding a reference tostd::unique_ptr
from anstd::auto_ptr
. This pattern doesn’t make much sense and usuallystd::auto_ptr
are stored by value (otherwise what is the point in using them instead of a reference or a pointer?).
// <3rd-party header...>
std::auto_ptr<int> get_value();
const std::auto_ptr<int> & get_ref();
// <calling code (with migration)...>
-std::auto_ptr<int> a(get_value());
+std::unique_ptr<int> a(get_value()); // ok, unique_ptr constructed from auto_ptr
-const std::auto_ptr<int> & p = get_ptr();
+const std::unique_ptr<int> & p = get_ptr(); // won't compile
Non-instantiated templates aren’t modified.
template <typename X>
void f() {
std::auto_ptr<X> p;
}
// only 'f<int>()' (or similar) will trigger the replacement.
Options¶
- IncludeStyle¶
A string specifying which include-style is used, llvm or google. Default is llvm.