It turns out that =delete is extremely useful! Here are a few examples:
Basically we can prevent copying base classes because it might often lead to slicing:
struct Base {
Base(){}
Base& operator=(const Base&) = delete; // disallow copying
Base(const Base&) = delete;
Base& operator=(Base && ) = delete; // disallow moving
Base(Base && ) = delete;
};
struct Der : public Base {};
void func() {
Der d;
Base base = d; // this won't work because the copy constructor is deleted!
// this behavior is desired - otherwise slicing would occur
}
It's also useful when a template function cannot run with a certain type:
template
void fn(T p) { /* ... */ }; // do something with T
void fn(int) = delete; // disallow use with int
void fun() {
fn(4); // aha! cannot use fn() with int!
fn(-4.5); // fine
fn("hello");// fine
}
=delete can also disallow undesired conversions:
struct Z {
Z(double); // can initialize with a double
Z(int) = delete; // but not with an integer
};
void f() {
Z z1 { 1 }; // error! can't use int
Z z2 { 1.0 }; // double is ok
}
Some more advanced uses of =delete include prohibiting stack or free store allocation:
class FS_Only {
~FS_Only() = delete; // disallow stack allocation
};
class Stack_Only {
void* operator new(size_t) = delete; // disallow heap allocation
};
... You get the idea. Hope this helps someone! =delete can help write readable, bugless and elegant code.
Edit:
As it was correctly pointed out in the comments, it is now impossible to delete FS_Only objects, so this one isn't such a good use of =delete after all.
