Bagaimana cara terbaik membungkam peringatan tentang variabel yang tidak digunakan?

Saya memiliki aplikasi lintas platform dan dalam beberapa fungsi saya tidak semua nilai yang diteruskan ke fungsi digunakan. Karenanya saya mendapat peringatan dari GCC yang memberi tahu saya bahwa ada variabel yang tidak digunakan.

Apa cara pengkodean terbaik di sekitar peringatan?

# Jika ada di sekitar fungsi?

#ifdef _MSC_VER
void ProcessOps::sendToExternalApp(QString sAppName, QString sImagePath, qreal qrLeft, qreal qrTop, qreal qrWidth, qreal qrHeight)
#else
void ProcessOps::sendToExternalApp(QString sAppName, QString sImagePath, qreal /*qrLeft*/, qreal /*qrTop*/, qreal /*qrWidth*/, qreal /*qrHeight*/)
#endif
{

Ini sangat jelek tetapi sepertinya cara kompiler lebih suka.

Atau apakah saya menetapkan nol pada variabel di akhir fungsi? (Yang saya benci karena itu mengubah sesuatu dalam aliran program untuk membungkam peringatan kompiler).

Apakah ada cara yang benar?

Anda bisa meletakkannya dalam (void)var;ekspresi " " (tidak melakukan apa - apa) sehingga kompiler melihatnya digunakan. Ini portabel antar kompiler.

Misalnya

void foo(int param1, int param2)
{
    (void)param2;
    bar(param1);
}

Atau,

#define UNUSED(expr) do { (void)(expr); } while (0)
...

void foo(int param1, int param2)
{
    UNUSED(param2);
    bar(param1);
}

Di GCC dan Dentang Anda dapat menggunakan __attribute__((unused))arahan preprosesor untuk mencapai tujuan Anda.
Sebagai contoh:

int foo (__attribute__((unused)) int bar) {
   return 0;
}

C ++ 17 sekarang menyediakan [[maybe_unused]]atribut.

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

Cukup bagus dan standar.

Solusi Anda saat ini adalah yang terbaik - beri komentar nama parameter jika Anda tidak menggunakannya. Itu berlaku untuk semua kompiler, jadi Anda tidak perlu menggunakan pra-prosesor untuk melakukannya secara khusus untuk GCC.

Pembaruan C ++ 17

Dalam C ++ 17 kita mendapatkan atribut [[mungkin_unused]] yang tercakup dalam [dcl.attr.unused]

Atribut-token maybe_unused menunjukkan bahwa nama atau entitas mungkin sengaja tidak digunakan. Itu akan muncul paling banyak sekali dalam setiap daftar atribut dan tidak ada atribut-argumen-klausa akan hadir. ...

Contoh:

 [[maybe_unused]] void f([[maybe_unused]] bool thing1,
                        [[maybe_unused]] bool thing2) {
  [[maybe_unused]] bool b = thing1 && thing2;
    assert(b);
 }

Implementasi tidak boleh memperingatkan bahwa b tidak digunakan, baik NDEBUG didefinisikan atau tidak. —Kirim contoh]

Untuk contoh berikut:

int foo ( int bar) {
    bool unused_bool ;
    return 0;
}

Baik dentang dan gcc menghasilkan diagnostik menggunakan -Wall -Wextra untuk bilah dan unused_bool ( Lihat langsung ).

Saat menambahkan [[mungkin_tidak digunakan]] membungkam diagnostik:

int foo ([[maybe_unused]] int bar) {
    [[maybe_unused]] bool unused_bool ;
    return 0;
}

lihat langsung .

Sebelum C ++ 17

Dalam C ++ 11 bentuk UNUSEDmakro alternatif dapat dibentuk menggunakan ekspresi lambda ( melalui Ben Deane ) dengan menangkap variabel yang tidak digunakan:

#define UNUSED(x) [&x]{}()

Doa langsung dari ungkapan lambda harus dioptimalkan, dengan memberikan contoh berikut:

int foo (int bar) {
    UNUSED(bar) ;
    return 0;
}

kita dapat melihat di godbolt bahwa panggilan dioptimalkan jauh:

foo(int):
xorl    %eax, %eax
ret

Cara yang lebih bersih adalah dengan mengomentari hanya nama variabel:

int main(int /* argc */, char const** /* argv */) {
  return 0;
}

Seorang rekan kerja hanya menunjuk saya ke makro kecil yang menyenangkan di sini

Untuk memudahkan saya akan menyertakan makro di bawah ini.

#ifdef UNUSED
#elif defined(__GNUC__) 
# define UNUSED(x) UNUSED_ ## x __attribute__((unused)) 
#elif defined(__LCLINT__) 
# define UNUSED(x) /*@unused@*/ x 
#else 
# define UNUSED(x) x 
#endif

void dcc_mon_siginfo_handler(int UNUSED(whatsig))

gcctidak menandai peringatan ini secara default. Peringatan ini harus dinyalakan baik secara eksplisit dengan meneruskan -Wunused-parameterke kompiler atau secara implisit dengan melewati -Wall -Wextra(atau mungkin beberapa kombinasi bendera lainnya).

Peringatan parameter yang tidak digunakan dapat dengan mudah ditekan dengan melewati -Wno-unused-parametercompiler, tetapi perhatikan bahwa flag penonaktifan ini harus datang setelah setiap kemungkinan flag yang memungkinkan untuk peringatan ini di baris perintah compiler, sehingga dapat berlaku.

cara makro-kurang dan portabel untuk mendeklarasikan satu atau lebih parameter sebagai tidak terpakai:

template <typename... Args> inline void unused(Args&&...) {}

int main(int argc, char* argv[])
{
    unused(argc, argv);
    return 0;
}

Menggunakan arahan preprosesor dianggap jahat sebagian besar waktu. Idealnya Anda ingin menghindari mereka seperti Hama. Ingatlah bahwa membuat kompiler memahami kode Anda itu mudah, membiarkan programmer lain memahami kode Anda jauh lebih sulit. Beberapa lusin kasus seperti ini di sana-sini membuatnya sangat sulit untuk dibaca sendiri nanti atau untuk orang lain sekarang.

Salah satu cara mungkin untuk menempatkan parameter Anda bersama-sama menjadi semacam kelas argumen. Anda kemudian dapat menggunakan hanya sebagian dari variabel (setara dengan Anda menetapkan 0 benar-benar) atau memiliki spesialisasi yang berbeda dari kelas argumen untuk setiap platform. Namun ini mungkin tidak sepadan, Anda perlu menganalisis apakah itu cocok.

Jika Anda dapat membaca templat yang tidak mungkin, Anda mungkin menemukan tips lanjutan di buku "Exceptional C ++". Jika orang-orang yang akan membaca kode Anda dapat memperoleh keahlian mereka untuk mencakup hal-hal gila yang diajarkan dalam buku itu, maka Anda akan memiliki kode yang indah yang juga dapat dengan mudah dibaca. Kompiler juga akan sangat menyadari apa yang Anda lakukan (alih-alih menyembunyikan semuanya dengan preprocessing)

Peringatan pertama dihasilkan oleh definisi variabel dalam file sumber bukan file header. Header dapat tetap asli dan harus, karena Anda mungkin menggunakan sesuatu seperti doxygen untuk menghasilkan dokumentasi API.

Saya akan berasumsi bahwa Anda memiliki implementasi yang sama sekali berbeda dalam file sumber. Dalam kasus ini, Anda dapat mengomentari parameter yang menyinggung atau hanya menulis parameter.

Contoh:

func(int a, int b)
{
    b;
    foo(a);
}

Ini mungkin tampak samar, sehingga mendefinisikan makro seperti TIDAK DIGUNAKAN. Cara MFC melakukannya adalah:

#ifdef _DEBUG
#define UNUSED(x)
#else
#define UNUSED(x) x
#endif

Seperti ini Anda melihat peringatan masih dalam debug membangun, mungkin bisa membantu.

Apakah tidak aman untuk selalu mengomentari nama parameter? Jika tidak, Anda dapat melakukan sesuatu seperti

#ifdef _MSC_VER
# define P_(n) n
#else
# define P_(n)
#endif

void ProcessOps::sendToExternalApp(
    QString sAppName, QString sImagePath,
    qreal P_(qrLeft), qreal P_(qrTop), qreal P_(qrWidth), qreal P_(qrHeight))

Ini sedikit lebih jelek.

Saya telah melihat ini alih-alih (void)param2cara membungkam peringatan:

void foo(int param1, int param2)
{
    std::ignore = param2;
    bar(param1);
}

Sepertinya ini ditambahkan di C ++ 11

Menggunakan UNREFERENCED_PARAMETER(p)bisa berhasil. Saya tahu itu didefinisikan dalam WinNT.h untuk sistem Windows dan dapat dengan mudah didefinisikan untuk gcc juga (jika belum memilikinya).

UNREFERENCED PARAMETER(p) didefinisikan sebagai

#define UNREFERENCED_PARAMETER(P)          (P)

di WinNT.h.

Gunakan flag compiler, mis. Flag untuk GCC: -Wno-unused-variable

Anda bisa menggunakan __unuseduntuk memberi tahu kompiler bahwa variabel mungkin tidak digunakan.

- (void)myMethod:(__unused NSObject *)theObject    
{
    // there will be no warning about `theObject`, because you wrote `__unused`

    __unused int theInt = 0;
    // there will be no warning, but you are still able to use `theInt` in the future
}

Di C ++ 11, ini adalah solusi yang saya gunakan:

template<typename... Ts> inline void Unreferenced(Ts&&...) {}

int Foo(int bar) 
{
    Unreferenced(bar);
    return 0;
}

int Foo2(int bar1, int bar2) 
{
    Unreferenced(bar1, bar2);
    return 0;
}

Diverifikasi sebagai perangkat portabel (setidaknya pada msvc modern, dentang dan gcc) dan tidak menghasilkan kode tambahan saat optimasi diaktifkan. Tanpa optimasi, pemanggilan fungsi ekstra dilakukan dan referensi ke parameter disalin ke stack, tetapi tidak ada makro yang terlibat.

Jika kode tambahan adalah masalah, Anda dapat menggunakan deklarasi ini sebagai gantinya:

(decltype(Unreferenced(bar1, bar2)))0;

tetapi pada saat itu, makro menyediakan keterbacaan yang lebih baik:

#define UNREFERENCED(...) { (decltype(Unreferenced(__VA_ARGS__)))0; }

Ini berfungsi dengan baik tetapi membutuhkan C ++ 11

template <typename ...Args>
void unused(Args&& ...args)
{
  (void)(sizeof...(args));
}

Saya menemukan sebagian besar jawaban yang disajikan hanya berfungsi untuk variabel lokal yang tidak digunakan, dan akan menyebabkan kesalahan kompilasi untuk variabel global statis yang tidak digunakan.

Makro lain diperlukan untuk menekan peringatan variabel global statis yang tidak digunakan.

template <typename T>
const T* UNUSED_VARIABLE(const T& dummy) { 
    return &dummy;
}
#define UNUSED_GLOBAL_VARIABLE(x) namespace {\
    const auto dummy = UNUSED_VARIABLE(x);\
}

static int a = 0;
UNUSED_GLOBAL_VARIABLE(a);

int main ()
{
    int b = 3;
    UNUSED_VARIABLE(b);
    return 0;
}

Ini berfungsi karena tidak ada peringatan yang akan dilaporkan untuk variabel global non-statis di ruang nama anonim.

Diperlukan C ++ 11

 g++  -Wall -O3  -std=c++11 test.cpp

Lol! Saya tidak berpikir ada pertanyaan lain pada SO yang mengungkapkan semua bidat yang dirusak oleh Chaos lebih baik dari yang ini!

Dengan segala hormat terhadap C ++ 17 ada pedoman yang jelas dalam Pedoman Inti C ++ . AFAIR, kembali pada tahun 2009 opsi ini tersedia serta hari ini. Dan jika seseorang mengatakan itu dianggap sebagai bug di Doxygen maka ada bug di Doxygen

Saya tidak melihat masalah Anda dengan peringatan itu. Dokumentasikan dalam header metode / fungsi yang dikompilasi xy akan mengeluarkan peringatan (benar) di sini, tetapi variabel tesis ini diperlukan untuk platform z.

Peringatan sudah benar, tidak perlu mematikannya. Itu tidak membatalkan program - tetapi harus didokumentasikan, bahwa ada alasannya.