How to delete constructors and operators using inheritance in c++?

Suppose I have two classes, no_copy and no_move which are base classes. From which any class can derive from and hence have their constructors and operators modified.

As the name suggests, no_copy will literally just do the following; (commented out what it should do)

class base : no_copy
{
    /*
       base(const base&)=delete;
       base& operator=(const base&)=delete;
    */
};

And the same for no_move,

class base : no_move
{
    /*
       base(base&&)=delete;
       base& operator=(base&&)=delete;
    */
};

These classes (no_copy & no_move) make it so that the class that derives from it should not be copyable or moveable.

Right now I am just using a macro to do this;

// For classes without a qualified name
#define __NO_COPY__(__class__) __class__::__class__(const __class__&)=delete; __class__& __class__::operator=(const __class__&)=delete;

// For classes with qualified names
#define __NO_COPY_LIB__(__qualified_name__,__class__) __qualified_name__::__class__(const __class__&)=delete; __class__& __qualified_name__::operator=(const __class__&)=delete;

And the same technique for not moving.

EDIT:
Examples of the macros;

suppose a class as such;

namespace wrapper
{
   class my_class {};

   __NO_COPY__(my_class);
}
__NO_COPY_LIB__(::wrapper::my_class,my_class);

The macros work just fine, but it doesn't look pretty. Moreover they are not easy to refactor as these macros can be anywhere in the definition or implementation.

A syntax like the following would mean that all of this in right there in the definition of the class and can be changed or modified very easily;

class base : public attributes<no_copy,no_move> {};

The attributes struct is just defined as;

template <typename... _BCs/*Base Classes*/>
struct attibutes : public _BCs... {};

Now obviously the syntax of inheriting doesn't matter that much. All I want it to be able to define where the class can be copied,moved or not. Also, if there is a method other than inheritance which could work please do suggest it.

As all I am looking for is the method that is easily refactorable.

I have tried finding solutions online about how to overload constructors. But so far I have not found anything about deleting them and hence I am doubting if it is even possible to delete constructors or operators using inheritance.

Any help would be greatly appreciated.

Special member functions delegate to the corresponding functions of their subobjects (bases and members) and will be defaulted as deleted if that delegation finds a deleted or inaccessible function.

• https://timsong-cpp.github.io/cppwp/n4868/class.ctor#class.copy.ctor-10
• https://timsong-cpp.github.io/cppwp/n4868/class.copy.assign#7

Although you could use a non-static member for this, using a base class is better because it enables the "Empty Base Optimization", not costing anything.

struct no_copy
{
protected:
    no_copy() = default;
    no_copy(const no_copy&) = delete;
    no_copy& operator=(const no_copy&) = delete;
};

class important_class : no_copy {};

pre-C++11 version:

class no_copy // members default to "private"
{
    no_copy(const no_copy&); // no definition needed
    no_copy& operator=(const no_copy&); // no definition needed
protected:
    no_copy() {}
};

This won't stop the derived class from defining a user-provided special member that explicitly avoids calling the base class version, but if you do that it shows intent to make the derived class actually be copyable/whatever after all.

As of C++20 and its new requires-expressions, this previously quite hasslesome of a task (e.g. implementing std::optional pre-C++20, mixins and so on) has now become quite neat, as we can conditionally delete a special member function based on traits to the common reusable attributes base class.

enum class options {
    no_default,
    no_copy,
    no_move,
};

template <options... opts>
struct attributes {
 protected:
    attributes() requires contains_v<options::no_default, opts...>               = delete;
    attributes() requires(!contains_v<options::no_default, opts...>)             = default;
    attributes(attributes const&) requires contains_v<options::no_copy, opts...> = delete;
    attributes& operator=(attributes const&) requires contains_v<options::no_copy, opts...> =
        delete;
    attributes(attributes&&) requires contains_v<options::no_move, opts...>            = delete;
    attributes& operator=(attributes&&) requires contains_v<options::no_move, opts...> = delete;
};

// Example usage
struct A : attributes<options::no_move, options::no_copy> {
    A() = default;
};

Helper trait:

template <options opt, options head, options... tail>
struct contains {
    static constexpr bool value{opt == head || contains<opt, tail...>::value};
};

template <options opt, options head>
struct contains<opt, head> {
    static constexpr bool value{false};
};

template <options opt, options... opts>
constexpr bool contains_v{contains<opt, opts...>::value};