std::ignore para ignorar la variable no utilizada

std::ignore puede funcionar, pero está destinado a ser utilizado para las tuplas. Por lo tanto, debe incluir el encabezado de la tupla y quién sabe qué operaciones se realizan para la asignación. Esto también puede romper en otra versión de c++ porque nunca fue documentado para ser utilizado de esa manera.

Una mejor manera para esto es el atributo C++17 [[maybe_unused]]

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

Coloca la declaración justo en la declaración de la variable, por lo que no tiene que declararla en una línea/declaración adicional.

Lo mismo se puede utilizar para variables locales (y locales estáticas)

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

Y también para muchos más:

Aparece en la declaración de una clase, a typedef, a variable, a miembro de datos no estático, una función, una enumeración o un enumerador. Si el compilador emite advertencias sobre entidades no utilizadas, esa advertencia es suprimido para cualquier entidad declarada maybe_unused.

Véase http://en.cppreference.com/w/cpp/language/attributes

En cuanto a las personas interesadas que se puede sigue usando las variables después de declararlas sin usar:

Sí, esto es posible, pero (al menos con clang) obtendrá advertencias en caso de que use maybe_unused variables declaradas.

Std::ignore no estaba destinado a ser utilizado para este propósito:

Un objeto de tipo no especificado tal que se le puede asignar cualquier valor sin efecto. Diseñado para su uso con std::tie al desempaquetar una std:: tupla, como un marcador de posición para los argumentos que no se utilizan.

Te sugeriría no hacer lo que estás pensando, ya que en un gran proyecto del mundo real, conducirá a un código que es más difícil de mantener, donde uno miraría el prototipo de una función, vería que toma un argumento int i, pero la función no necesitaría que en realidad - no se siente bien, ¿verdad? :)

Como alternativa, sin quitar i de la firma (como algunas herramientas de documentación pueden requerirlo), hay varias maneras de silenciar la advertencia:

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

No es completamente portable, pero eso silencia la advertencia en la mayoría de los compiladores.

La manera limpia es crear una función dedicada para eso:

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

Y luego

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

Creo que tienes un problema XY aquí. Realmente no te importa cómo ignorar las variables estáticas; solo quieres llamar a una función una vez (y solo una vez) de una manera reentrante y segura para subprocesos.

A lo que yo digo: ¿has oído hablar std::call_once? Debe reescribir su método como

#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);
 }

Otra forma de hacerlo es por medio de un tipo de retorno final como el siguiente:

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

Si tiene más de una variable, puede enumerarlas todas:

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

Y aún puede declarar su tipo de devolución preferido si void no es lo que desea:

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

Las ventajas de esta solución son:

• El nombre de la variable se conserva: como han mencionado otros, no dar un nombre a la variable no podría ser una opción (debido a su sistema de documentación, como ejemplo).

• No contaminará su cuerpo de función con expresiones inútiles destinadas a silenciar algunas advertencias.

• No tiene que definir explícitamente la función de soporte para hacer eso.

Por supuesto, esto no se aplica a las variables estáticas declaradas en el cuerpo de la función, pero puede hacer algo similar al regresar de la función (solo un ejemplo):

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

int main () {}

Más o menos las mismas ventajas.