Po co rzutować nieużywane wartości zwracane na void?

int fn();

void whatever()
{
    (void) fn();
}

Czy istnieje jakiś powód, aby rzutować nieużywaną wartość zwracaną na void, czy też mam rację, myśląc, że to kompletna strata czasu?

Zagryźć:

Cóż, wydaje się to dość wyczerpujące. Przypuszczam, że jest to lepsze niż komentowanie nieużywanej wartości zwracanej, ponieważ samodokumentujący kod jest lepszy niż komentarze. Osobiście wyłączę te ostrzeżenia, ponieważ jest to niepotrzebny hałas.

Zjem moje słowa, jeśli z tego powodu ucieknie błąd ...

Odpowiedź Davida prawie obejmuje motywację do tego, aby wyraźnie pokazać innym „programistom”, że wiesz, że ta funkcja zwraca, ale wyraźnie ją ignorujesz.

Jest to sposób na zapewnienie, że w razie potrzeby kody błędów są zawsze obsługiwane.

Myślę, że w przypadku C ++ jest to prawdopodobnie jedyne miejsce, w którym wolę również używać rzutów w stylu C, ponieważ używanie pełnej notacji rzutowania statycznego wydaje się tutaj przesadą. Na koniec, jeśli przeglądasz standard kodowania lub piszesz go, dobrym pomysłem jest również jawne stwierdzenie, że wywołania przeciążonych operatorów (nie używających notacji wywołań funkcji) również powinny być z tego zwolnione:

class A {};
A operator+(A const &, A const &);

int main () {
  A a;
  a + a;                 // Not a problem
  (void)operator+(a,a);  // Using function call notation - so add the cast.

W pracy używamy tego do uznania, że ​​funkcja ma wartość zwracaną, ale programista zapewnił, że można ją bezpiecznie zignorować. Ponieważ oznaczyłeś pytanie jako C ++, powinieneś używać static_cast :

static_cast<void>(fn());

Jeśli chodzi o kompilator, rzutowanie zwracanej wartości na void ma niewielkie znaczenie.

Prawdziwy powód takiego działania sięga narzędzia używanego w kodzie C, zwanego lint .

Analizuje kod pod kątem możliwych problemów oraz wydaje ostrzeżenia i sugestie. Gdyby funkcja zwróciła wartość, która nie została następnie sprawdzona, lintostrzegałaby, gdyby było to przypadkowe. Aby uciszyć lintto ostrzeżenie, rzucasz wezwanie do (void).

Rzutowanie na voidsłuży do pomijania ostrzeżeń kompilatora dla nieużywanych zmiennych i niezapisanych zwracanych wartości lub wyrażeń.

Standard (2003) mówi w §5.2.9 / 4 mówi:

Każde wyrażenie można jawnie przekonwertować na typ „cv void”. Wartość wyrażenia jest odrzucana .

Możesz więc napisać:

//suppressing unused variable warnings
static_cast<void>(unusedVar);
static_cast<const void>(unusedVar);
static_cast<volatile void>(unusedVar);

//suppressing return value warnings
static_cast<void>(fn());
static_cast<const void>(fn());
static_cast<volatile void>(fn());

//suppressing unsaved expressions
static_cast<void>(a + b * 10);
static_cast<const void>( x &&y || z);
static_cast<volatile void>( m | n + fn());

Wszystkie formularze są ważne. Zwykle skracam go jako:

//suppressing  expressions
(void)(unusedVar);
(void)(fn());
(void)(x &&y || z);

To też jest w porządku.

Od c ++ 17 mamy [[maybe_unused]]atrybut, którego można użyć zamiast voidrzutowania.

Rzucanie w pustkę jest darmowe. Jest to tylko informacja dla kompilatora, jak go traktować.

Ponieważ funkcja rzutowania programu na void jest bez znaczenia. Twierdzę również, że nie należy go używać do sygnalizowania czegoś osobie, która czyta kod, jak sugeruje David w odpowiedzi. Jeśli chcesz przekazać coś o swoich zamiarach, lepiej użyć komentarza. Dodanie takiej obsady będzie wyglądać dziwnie i wywoła pytania o możliwy powód. Tylko moja opinia...

Również podczas weryfikacji kodu zgodnego ze standardami MISTA (lub innymi), automatyczne narzędzia, takie jak LDRA, nie pozwolą Ci wywołać funkcji, która ma typ zwracany bez zwracania przez nią wartości, chyba że jawnie rzutujesz zwróconą wartość na (void)

C ++ 17 [[nodiscard]]

C ++ 17 ustandaryzował „zwracaną wartość biznesową ignorowaną” za pomocą atrybutu.

Dlatego mam nadzieję, że zgodne implementacje zawsze będą ostrzegać tylko wtedy, gdy nodiscardzostaną podane, i nigdy nie będą ostrzegać inaczej.

Przykład:

main.cpp

[[nodiscard]] int f() {
    return 1;
}

int main() {
    f();
}

skompilować:

g++ -std=c++17 -ggdb3 -O0 -Wall -Wextra -pedantic -o main.out main.cpp

wynik:

main.cpp: In function ‘int main()’:
main.cpp:6:6: warning: ignoring return value of ‘int f()’, declared with attribute nodiscard [-Wunused-result]
    6 |     f();
      |     ~^~
main.cpp:1:19: note: declared here
    1 | [[nodiscard]] int f() {
      | 

Poniższe wszystkie pozwalają uniknąć ostrzeżenia:

(void)f();
[[maybe_unused]] int i = f();

Nie mogłem użyć maybe_unusedbezpośrednio podczas f()rozmowy:

[[maybe_unused]] f();

daje:

main.cpp: In function ‘int main()’:
main.cpp:6:5: warning: attributes at the beginning of statement are ignored [-Wattributes]
    6 |     [[maybe_unused]] f();
      |     ^~~~~~~~~~~~~~~~

Działanie (void)rzutowania nie wydaje się być obowiązkowe, ale standard jest „ zalecany ”: Jak celowo odrzucić wartość zwracaną przez [[nodiscard]]?

Jak widać z komunikatu ostrzegawczego, jednym „rozwiązaniem” ostrzeżenia jest dodanie -Wno-unused-result:

g++ -std=c++17 -ggdb3 -O0 -Wall -Wextra -pedantic -Wno-unused-result -o main.out main.cpp

chociaż oczywiście nie polecałbym ignorowania takich ostrzeżeń na całym świecie.

C ++ 20 pozwala również dodać powód do nodiscardjak w, [[nodiscard("reason")]]jak wspomniano na: https://en.cppreference.com/w/cpp/language/attributes/nodiscard

warn_unused_resultAtrybut GCC

Przed standaryzacją [[nodiscard]]i dla C zanim ostatecznie zdecydują się na standaryzację atrybutów, GCC zaimplementowało dokładnie tę samą funkcjonalność z warn_unused_result:

int f() __attribute__ ((warn_unused_result));

int f() {
    return 1;
}

int main() {
    f();
}

co daje:

main.cpp: In function ‘int main()’:
main.cpp:8:6: warning: ignoring return value of ‘int f()’, declared with attribute warn_unused_result [-Wunused-result]
    8 |     f();
      |     ~^~

Należy zatem zauważyć, że ponieważ ANSI C nie ma na to standardu, ANSI C nie określa, które funkcje biblioteki standardowej C mają atrybut lub nie, a zatem implementacje podjęły własne decyzje dotyczące tego, co powinno lub nie być oznaczone warn_unuesd_result, co dlatego generalnie należałoby użyć (void)rzutowania, aby zignorować zwrot wszelkich wywołań funkcji biblioteki standardowej, aby w pełni uniknąć ostrzeżeń w jakiejkolwiek implementacji.

Przetestowano w GCC 9.2.1, Ubuntu 19.10.