The under-evaluated delete specifier

As you should know by now in C++11 we are able disable certain signatures in our classes. Most of the time this is used to disable copy constructor and assignment operators

	class NonCopyable {
	public:
	NonCopyable(const NonCopyable&) = delete;
	NonCopyable& operator=(const NonCopyable&) = delete;
	private:
	...
	}

view raw noncopyable hosted with ❤ by GitHub

this way is much better than the old way where the programmer had to declare private both member and then not implement them getting an error either at compile time or either at linking time.

The delete specifier can disable some automatic overloads consider indeed the following code

	class DoublePrinter {
	public:
	void print(double aDouble) {
	std::cout << "Value is: " << aDouble << std::endl;
	}
	};
	DoublePrinter dp;
	dp.print(3.3f);

view raw doubleprinter hosted with ❤ by GitHub

it works perfectly but if we do not want that automatic conversion (note that explicit can not be used here) then the delete specifier can come in handy

	class DoublePrinter {
	public:
	void print(double aDouble) {
	std::cout << "Value is: " << aDouble << std::endl;
	}
	void print(float) = delete;
	};

view raw doubleprinterdelete hosted with ❤ by GitHub

A typical mistake in C++ is to store a reference (or a pointer for the matter) to a temporary object leading to a disaster. This mistake is one of the argument java guys put on the table when they are arguing against C++.

The following class is a perfectly working class but used wrongly can store a reference to a temporary object

	class CrashDestination {
	public:
	CrashDestination(const std::string& aString)
	: theString(aString)
	{}
	void print() const { std::cout << theString << std::endl; }
	private:
	const std::string& theString;
	};
	CrashDestination cd("TEMPORARY_STRING");
	cd.print();

view raw crashdestination hosted with ❤ by GitHub

The delete specifier can help us again indeed we can disable the constructor with a rvalue reference and avoid such use:

	class CrashDestination {
	public:
	CrashDestination(const std::string& aString)
	: theString(aString)
	{}
	CrashDestination(const std::string&&) = delete;
	void print() const { std::cout << theString << std::endl; }
	private:
	const std::string& theString;
	};

view raw rvaluedisabled hosted with ❤ by GitHub

now the code above will lead to a compilation error in case we are trying to build the class with a temporary string, you should note that a "const &&" is needed, indeed without the const specifier passing a "const std::string foo()" will not led to a compilation error

Time to add to my coding rules a new rule!