Let’s talk about copying objects in C++. Test t;, calls the default constructor, which allocates a new array of integers. This is fine, and your expected behavior. Trouble comes when you push t into your queue using q.push(t). If you’re familiar with Java, C#, or almost any other object-oriented language, you might expect the object … Read more
It’s perfectly “safe” to delete a null pointer; it effectively amounts to a no-op. The reason you might want to check for null before you delete is that trying to delete a null pointer could indicate a bug in your program. Edit NOTE: if you overload the delete operator, it may no longer be “safe” … Read more
This works for me in MSVC10 int x = 5; auto del = [](int * p) { std::cout << “Deleting x, value is : ” << *p; }; std::unique_ptr<int, decltype(del)> px(&x, del); And on gcc 4.5, here I’ll skip going to the standard, unless you don’t think that example is doing exactly what you’d expect … Read more
Prior to C++20, objects’ destructors were always called prior to calling their operator delete. With destroying operator delete in C++20, operator delete can instead call the destructor itself. Here’s a very simple toy example of non-destroying vs. destroying operator delete: #include <iostream> #include <new> struct Foo { ~Foo() { std::cout << “In Foo::~Foo()\n”; } void … Read more
delete[] monsters; Is incorrect because monsters isn’t a pointer to a dynamically allocated array, it is an array of pointers. As a class member it will be destroyed automatically when the class instance is destroyed. Your other implementation is the correct one as the pointers in the array do point to dynamically allocated Monster objects. … Read more
Part I This C++ FAQ entry explained why one might want to overload new and delete operators for one’s own class. This present FAQ tries to explain how one does so in a standard-conforming way. Implementing a custom new operator The C++ standard (ยง18.4.1.1) defines operator new as: void* operator new (std::size_t size) throw (std::bad_alloc); … Read more
You can call clear, and that will destroy all the objects, but that will not free the memory. Looping through the individual elements will not help either (what action would you even propose to take on the objects?) What you can do is this: vector<tempObject>().swap(tempVector); That will create an empty vector with no memory allocated … Read more
One may try to replace new and delete operators for a number of reasons, namely: To Detect Usage Errors: There are a number of ways in which incorrect usage of new and delete may lead to the dreaded beasts of Undefined Behavior & Memory leaks. Respective examples of each are: Using more than one delete … Read more
No, it is not safe to call delete on a stack-allocated variable. You should only call delete on things created by new. For each malloc or calloc, there should be exactly one free. For each new there should be exactly one delete. For each new[] there should be exactly one delete[]. For each stack allocation, … Read more
Use ::std::vector! Type* t = (Type*)malloc(sizeof(Type)*n) memset(t, 0, sizeof(Type)*m) becomes ::std::vector<Type> t(n, 0); Then t = (Type*)realloc(t, sizeof(Type) * n2); becomes t.resize(n2); If you want to pass pointer into function, instead of Foo(t) use Foo(&t[0]) It is absolutely correct C++ code, because vector is a smart C-array.