Вопрос о шаблоне Language C++

Почему вы передаете ! ReadWriteActivated вместо readWriteActivated , если значение выражения не имеет значения?

Обычный (и гораздо более простой) способ добиться этого - просто привести результат к void .

(void) x;

где x - какое-то другое значение, на которое нет ссылки.

Чарльз Николсон предлагает сделать что-то подобное для пометки неиспользуемых переменных по причинам, объясненным в этой статье :

#define UNSUSED(a) ((void)sizeof(a))

Короткая версия... sizeof не оценивает выражение, но компиляторы все равно считают его "использованным", когда его видят в этом контексте.

Я считаю, что это удовлетворяет всем 4 вашим критериям, а именно потому, что sizeof() может принять любое корректное выражение, и потому, что выражение не будет вычислено (и, следовательно, не сгенерирует никакого кода).

Измените определение unused:

inline void unused(bool) {}

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

Кроме того, это устраняет общую проблему с большинством макросов assert: если выражение действительно имеет побочные эффекты, они всегда будут вычисляться. (В зависимости от использования это может быть очень хорошо или очень плохо.)

Почему бы вообще не пропустить шаблоны и не использовать многоточия.

inline void unused (...) { /* do nothing */ }

Если вы хотите подавить предупреждение о неиспользуемой переменной, почему вы называете ее
. неиспользованный(!readWriteActivated); ? Почему ты не можешь просто назвать это
неиспользуемый(readWriteActivated); и сделайте код как

template<typename T>
void UnUsed(const T& )
{

}

Для более подробных ссылок смотрите запись в блоге от Herb Sutter Here

EDIT: Удалено имя параметра в функции. Это работает для неиспользуемая(!readWriteActivated); а также.

Предупреждение компилятора не имеет никакого отношения к используемому или неиспользуемому. Передается переменная volatile - readWriteActivated - в функцию, которая не принимает volatile reference. Попробуйте const cast.

Лучшее решение, которое я видел, похоже на это:

#define UNUSED(x) ((void)x)

Это портативно, и подавляет предупреждение успешно.

Редактировать :

Так как вы заявили, что это больше похоже на утверждение, то вы, вероятно, должны сделать что-то вроде этого:

#if defined ASSERT_ENABLED
#define TEST(test) (!(test)) ? assert_failed(# test, __FILE__, __LINE__) : (void)0    
#else
#define TEST(ignore) ((void)0)
#endif

Это даст никакого кода, если assert_enabled определяется и не даст предупреждение о неиспользованных переменных. Это в значительной степени как Assert макрос в LIBC работает.

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

Это ошибка:

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=42655

На уровне unused () нет никакого решения. Вместо этого каждое вхождение можно обойти, введя временную переменную перед вызовом unused ():

template<typename T>
void
unused(T const &) {
  /* Do nothing. */
}

int main() {
  volatile bool x = false;
  bool avoidGCC42655 = !x; // type of "!x" is bool
  unused(avoidGCC42655);
}