Являются ли нечистые виртуальные функции с параметрами плохой практикой?

Игнорируя проблемы дизайна, вы можете обойти предупреждение компилятора о неиспользуемой переменной, опустив имя переменной, например:

virtual void OnlyImplementThisSometimes(int ) { }

Ошибочная реализация неправильной сигнатуры метода при попытке переопределить виртуальную функцию — это то, с чем вам нужно быть осторожным в C++. Такие языки, как C#, обходят это с помощью ключевого слова override.

Мы определяем макрос _unused как:

#define _unused(x) ((void)x)

Затем определите функцию как:

virtual void OnlyImplementThisSometimes(int x) { _unused( x );}

Это не только предотвращает жалобы компилятора, но и делает очевидным для любого, кто поддерживает код, что вы не забыли об x - вы намеренно его игнорируете.

Зачем определять его в базовом классе? Если базовый класс не собирается использовать этот метод, просто определите его как виртуальный метод в производном классе.

Или реализация по умолчанию может вызвать исключение

Если вы предоставляете реализацию виртуальной функции по умолчанию, она должна быть правильной реализацией для всех производных классов, которые не переопределяют эту функцию. Если вы не можете предоставить правильную реализацию, то я бы посоветовал создать чисто виртуальную функцию и предоставить производному классу возможность реализации. Производные классы, которые не позволяют вызывать метод, могут генерировать исключение, чтобы гарантировать, что он не будет использован по ошибке.

В дополнение к простому опусканию имени переменной во многих компиляторах вы можете сообщить компилятору, что вы знаете, что оно не используется, и SHUTUP, сделав это.

int func(int x)
{
   (void) x;
}

Это довольно часто встречается в моем коде. Например, у меня есть классы, предназначенные для однопоточной работы и многопоточные. Есть много общих процедур и данных. Я поместил все это в базовый класс (который также имеет пару чистых виртуальных).

Я реализую две пустые виртуальные функции в базовом классе: Init() и Cleanup(). Однопоточный производный класс их не реализует, а многопоточный делает.

У меня есть фабричная функция, создающая соответствующий производный класс, а затем возвращающая указатель. Клиентский код знает только о типе базового класса и вызывает Init() и Cleanup(). Оба сценария работают правильно.

Конечно, могут быть и другие хорошие предложения о том, как это сделать, но эта идиома хорошо работает для большей части моего кода.

Это неплохая практика, и это обычная идиома для указания частей класса, которые необязательны для реализации.

В настоящее время я использую его для системы пользовательского ввода, потому что пользователю этого класса было бы утомительно реализовывать каждый метод, даже если он, скорее всего, все равно не будет его использовать.

class mouse_listener{
public:
    virtual ~mouse_listener() {}

    virtual void button_down(mouse_button a_Button) {}
    virtual void button_up(mouse_button a_Button) {}
    virtual void scroll_wheel(mouse_scroll a_Scroll) {}
    virtual void mouse_move_abs(math::point a_Position) {}
    virtual void mouse_move_rel(math::point a_Position) {}
};

Кстати, если вы знаете свой базовый класс, никогда не будет необходимости делать динамические up-приведения, то есть от производного к базовому.

Base *b = &d;

Сработает так же хорошо, вместо этого следует использовать dynamic_cast<>, когда вы выполняете приведение вниз, то есть от основы к производной:

if((Derived *d = dynamic_cast<Derived *>(b)) != 0)
{
  // use d
}

(И, конечно же, в случае приведения вниз static_cast<> обычно также работает.)

Попробуй это:

class Base {
    virtual void OnlyImplementThisSometimes(int x) = 0;
};

Прошло некоторое время с тех пор, как я делал подобные вещи, но я считаю, что именно так вы объявляете виртуальную функцию.

Также, как говорили другие, имена переменных не являются обязательными в объявлениях функций, подобных этому.

Самый простой ответ на это показан ниже:

class Base {
    virtual void OnlyImplementThisSometimes(int x) { x;}
};

Простая ссылка на переменную, которая абсолютно ничего не делает, удалит все предупреждения (во всяком случае, из VC++ на самом высоком уровне).