Forward declaration with unique_ptr? [duplicate]

by

It’s explicitly legal. The rule is that the types used to instantiate
a template in the standard library must be complete, unless otherwise
specified. In the case of unique_ptr, §20.7.1/5 says “[…] The
template parameter T of unique_ptr may be an incomplete type.”

There are certain operations on the pointer which require a complete
type; in particular, when the object will actually be destructed (at
least with the default deleter). In your example, for example, if
A::~A() were inline, this might cause problems. (Note that if you
don’t declare the destructor yourself, it will be inline. Which
partially defeats the purpose of using std::unique_ptr.)

More Related Contents:

  1. Why, really, deleting an incomplete type is undefined behaviour?
  2. If you shouldn’t throw exceptions in a destructor, how do you handle errors in it?
  3. make_unique and perfect forwarding
  4. How do I pass a unique_ptr argument to a constructor or a function?
  5. Pure virtual destructor in C++
  6. std::unique_ptr with an incomplete type won’t compile
  7. Differences between unique_ptr and shared_ptr [duplicate]
  8. How to implement make_unique function in C++11? [duplicate]
  9. What is the use of having destructor as private?
  10. Destructors of builtin types (int, char etc..)
  11. So can unique_ptr be used safely in stl collections?
  12. In C++, is it possible to forward declare a class as inheriting from another class?
  13. Will exit() or an exception prevent an end-of-scope destructor from being called?
  14. What is the header?
  15. How to add constructors/destructors to an unnamed class?
  16. What is forward declaration in c++? [duplicate]
  17. Calling initializer_list constructor via make_unique/make_shared
  18. Should I use shared_ptr or unique_ptr
  19. C++ class forward declaration
  20. problems with Move constructor and Move overloaded assignment operator?
  21. Why does a C++ friend class need a forward declaration only in other namespaces?
  22. Why does destructor disable generation of implicit move methods?
  23. forward declaration with vector of class type – pointer to incomplete class type not allowed
  24. unique_ptr and OpenSSL’s STACK_OF(X509)*
  25. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  26. Are destructors run when calling exit()? [duplicate]
  27. Should std::unique_ptr be permitted
  28. Does std::bind work with move-only types in general, and std::unique_ptr in particular?
  29. Is the whole object freed with a non-virtual destructor and a Base class pointer?
  30. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?

Leave a Comment