std :: ignore для игнорирования неиспользуемой переменной

В таком случае просто не пишите имя переменной:

void func(int /*i*/)
{
    ...
}

@ Hayt ответ хорош, но использует последнюю версию C ++, которая не всегда доступна. Отказ от записи имени переменной - это старое соглашение, чтобы сообщить компилятору, что на самом деле эта переменная вам не нужна.

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

class SomethingInitializer {
public:
    SomethingInitializer() {
        func_returnSomething();
    }
    ~SomethingInitializer() {
        // Note, that when you initialize something it is a good practice to deinitialize it at the end, and here is a proper place for that.
    }
};

void func() {
    static SomethingInitializer initializer;
}

У этого решения есть небольшой бонус: SomethingInitializer совместим с RAII. Поэтому, когда приложение завершает работу, вызывается деструктор, который может выполнить деинициализацию.

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

std::ignore может работать, но он предназначен для использования с кортежами. Итак, вам нужно включить заголовок кортежа и кто знает, какие операции выполняются для назначения. Это также может сломаться в другой версии C ++, потому что никогда не было задокументировано для использования таким образом.

Лучше всего для этого использовать атрибут C ++ 17 [[maybe_unused]]

void func([[maybe_unused]] int i)
{
}

Он помещает объявление прямо в объявление переменной, поэтому вам не нужно объявлять его в дополнительной строке / операторе.

То же самое можно использовать для локальных (и локально-статических) переменных.

...
[[maybe_unused]] static int a = something();
...

А также для многих других:

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

См. http://en.cppreference.com/w/cpp/language/attributes.

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

Да, это возможно, но (по крайней мере, с помощью clang) вы получите предупреждения в случае использования maybe_unused объявленных переменных.

std :: ignore не предназначен для использования с этой целью:

Объект неопределенного типа, которому может быть присвоено любое значение без какого-либо эффекта. Предназначен для использования с std :: tie при распаковке std :: tuple в качестве заполнителя для неиспользуемых аргументов.

Я бы посоветовал вам не делать то, о чем вы думаете, поскольку в реальном большом проекте это приведет к тому, что код, который будет труднее поддерживать, когда можно будет посмотреть на прототип функции, будет видите, что он принимает аргумент int i, но на самом деле функции он не нужен - неприятно, не так ли? :)

В качестве альтернативы, не удаляя i из подписи (поскольку это может потребоваться для некоторых инструментов документации), есть несколько способов отключить предупреждение:

void func(int i)
{
   static_cast<void>(i); // Silent warning for unused variable
}

Он не является полностью переносимым, но не предупреждает о предупреждении большинства компиляторов.

Чистый способ - создать для этого специальную функцию:

template <typename T>
void Unused(T&& /*No name*/) { /*Empty*/ }

а потом

void func(int i)
{
   Unused(i); // Silent warning for unused variable
}

Я думаю, у вас здесь проблема XY. На самом деле вас не волнует, как игнорировать статические переменные; вы просто хотите вызвать функцию один раз (и только один раз) потокобезопасным, реентерабельным способом.

На что я говорю: вы слышали о std::call_once? Вам следует переписать свой метод как

#include <mutex>

int Thread_UnSafe_func_returnSomething();
void func(void)
{
      //To make it thread safe
     static std::once_flag initComplete;
     std::call_once(initComplete, func_returnSomething);
 }

Другой способ сделать это - использовать следующий конечный возвращаемый тип:

auto func(int i) -> decltype(void(i)) {}
int main() {}

Если у вас более одной переменной, вы можете перечислить их все:

auto func(int i, int j) -> decltype(void(i), void(j)) {}
int main() {}

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

auto func(int i) -> decltype(void(i), int{}) { return 42; }
int main() {}

Преимущества этого решения:

• Имя переменной сохраняется: как упоминалось другими, не давать имя переменной не может быть вариантом (например, из-за вашей системы документации).

• Вы не засорете тело своей функции бесполезными выражениями, призванными заглушить несколько предупреждений.

• Для этого вам не нужно явно определять функцию поддержки.

Конечно, это не относится к статическим переменным, объявленным в теле функции, но вы можете сделать что-то подобное при возврате из функции (просто пример):

int f() {
    static int i = 0;
    static int j = 0;
    return void(i), void(j), 42;
}

int main () {}

Больше или меньше тех же преимуществ.

Я хотел бы предложить альтернативу тем, кто компилирует на ARM.

Вы можете использовать _ атрибут _ keyword < / a>, чтобы присвоить переменной неиспользуемый атрибут. Это приведет к тому, что компилятор не будет выдавать никаких предупреждений, если на переменную нет ссылки.

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

Пример:

void someFunc(int x __attribute__((unused)) );

Ссылку на документацию можно найти здесь.