Are there any valid use cases to use new and delete, raw pointers or c-style arrays with modern C++?

by

When ownership should not be local.

As an example, a pointer container may not want ownership over the pointers in it to reside in the pointers themselves. If you try to write a linked list with forward unique ptrs, at destruction time you can easily blow the stack.

A vector-like container of owning pointers may be better suited to storing delete operation at the container or subcontainer level, and not at the element level.

In those and similar cases, you wrap ownership like a smart pointer does, but you do it at a higher level. Many data structures (graphs, etc) may have similar issues, where ownership properly resides at a higher point than where the pointers are, and they may not map directly to an existing container concept.

In some cases it may be easy to factor out the container-ownership from the rest of the data structure. In others it may not.

Sometimes you have insanely complex non-local non-reference counted lifetimes. There is no sane spot to put the ownership pointer in those cases.

Determining correctness here is hard, but not impossible. Programs that are correct and have such complex ownership semantics exist.

All of these are corner cases, and few programmers should run into them more than a handful of times in a career.

More Related Contents:

  1. Passing capturing lambda as function pointer
  2. Idiom for iterating “between each consecutive pair of elements” [duplicate]
  3. Is std::string ref-counted in GCC 4.x / C++11?
  4. How std::function works
  5. GNU C++ how to check when -std=c++0x is in effect?
  6. Clang doesn’t see basic headers
  7. std::thread error (thread not member of std)
  8. What would a std::map extended initializer list look like?
  9. Are lambdas inlined like functions in C++?
  10. Using libstdc++ compiled libraries with clang++ -stdlib=libc++
  11. Double-Checked Lock Singleton in C++11
  12. What is “->” after function declaration?
  13. Why Aren’t `std::uniform_int_distribution` and `std::uniform_int_distribution` Allowed?
  14. Why can’t I use with g++ 4.9.2?
  15. C++11 Change `auto` Lambda to a different Lambda?
  16. how to specify vc11 lambda calling convention
  17. Partial specialization of function templates
  18. Why does std::forward have two overloads?
  19. Add elements to a vector during range-based loop c++11
  20. Does std::bind work with move-only types in general, and std::unique_ptr in particular?
  21. Dynamic dispatching of template functions?
  22. C++11 cross compiler/standard library random distribution reproducibility
  23. Is it possible to invoke a user-defined conversion function via list-initialization?
  24. Is there a proper ‘ownership-in-a-package’ for ‘handles’ available?
  25. About thread-safety of weak_ptr
  26. Is there a reference_wrapper for rvalue references?
  27. Move constructor on derived object
  28. using declaration in variadic template
  29. get part of std::tuple
  30. Using Boost adaptors with C++11 lambdas

Leave a Comment