Kullanılmayan değişkenlerle ilgili bir uyarıyı en iyi nasıl sustururum?

Bir çapraz platform uygulamam var ve bazı işlevlerimde işlevlere iletilen tüm değerler kullanılmıyor. Bu nedenle GCC'den kullanılmayan değişkenler olduğunu belirten bir uyarı alıyorum.

Uyarı etrafında kodlamanın en iyi yolu ne olurdu?

#İfdef fonksiyonun etrafında mı?

#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
{

Bu çok çirkin ama derleyicinin tercih ettiği gibi görünüyor.

Yoksa işlevin sonunda değişkene sıfır atayabilir miyim? (ki bu bir nefret ediyorum çünkü bir derleyici uyarısını susturmak için program akışındaki bir şeyi değiştiriyor).

Doğru bir yol var mı?

Şunları yapabilirsiniz "koymak (void)var;ifadesi" (hiçbir şey yapmaz) bir derleyici kullanıldığı görür böylece. Bu derleyiciler arasında taşınabilir.

Örneğin

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

Veya,

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

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

GCC ve Clang'da __attribute__((unused))hedefinize ulaşmak için önişlemci direktifini kullanabilirsiniz.
Örneğin:

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

C ++ 17 şimdi [[maybe_unused]]özniteliği sağlar.

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

Oldukça güzel ve standart.

Mevcut çözümünüz en iyisidir - kullanmıyorsanız parametre adını yorumlayın. Bu tüm derleyiciler için geçerlidir, bu yüzden ön işlemciyi GCC için özel olarak yapmak zorunda değilsiniz.

C ++ 17 Güncellemesi

C ++ 17'de, [dcl.attr.unused] ile kapsanan [[belki_unused]] özelliğini kazanırız

Özellik belirteci maybe_unused, bir adın veya varlığın muhtemelen kasıtlı olarak kullanılmadığını gösterir. Her nitelik listesinde en fazla bir kez görünecek ve hiçbir nitelik-argüman-maddesi bulunmayacaktır. ...

Misal:

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

Uygulamalar, NDEBUG tanımlı olsun veya olmasın, b'nin kullanılmadığı konusunda uyarmamalıdır. —End örneği]

Aşağıdaki örnek için:

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

Hem clang hem de gcc, bar ve unused_bool için -Wall -Wextra kullanarak bir tanı oluşturur ( Canlı olarak görün ).

[[Maybe_unused]] eklenirken tanılama susturulur :

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

canlı görün .

C ++ 17'den önce

C ++ 11'de , kullanılmayan değişkenin yakalanmasıyla UNUSEDbir lambda ifadesi ( Ben Deane aracılığıyla ) kullanılarak makronun alternatif bir formu oluşturulabilir :

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

Aşağıdaki örnek göz önüne alındığında lambda ifadesinin derhal çağrılması optimize edilmelidir:

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

Godbolt'ta aramanın optimize edildiğini görebiliriz :

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

Daha da temiz bir yol, değişken adlarını yorumlamaktır:

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

Bir iş arkadaşım beni buradaki bu güzel makroya işaret etti

Kolaylık için aşağıdaki makroyu ekleyeceğim.

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

gccvarsayılan olarak bu uyarıları işaretlemez. Bu uyarının -Wunused-parameterderleyiciye geçirilerek veya dolaylı olarak iletilerek -Wall -Wextra(veya muhtemelen başka bir bayrak birleşimi yoluyla) açılmış olması gerekir .

Kullanılmayan parametre uyarıları -Wno-unused-parameterderleyiciye iletilerek kolayca bastırılabilir , ancak bu devre dışı bırakma bayrağının derleyici komut satırında bu uyarı için olası etkinleştirme işaretlerinden sonra gelmesi gerektiğini unutmayın, böylece etkili olabilir.

bir veya daha fazla parametreyi kullanılmayan olarak bildirmek için makro içermeyen ve taşınabilir bir yol :

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

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

Önişlemci direktiflerinin kullanılması çoğu zaman kötü olarak kabul edilir. İdeal olarak zararlılardan kaçınmak istersiniz. Derleyicinin kodunuzu anlamasını sağlamanın, diğer programcıların kodunuzu anlamasını sağlamanın çok daha zor olduğunu unutmayın. Burada bunun gibi birkaç düzine vaka, kendiniz için daha sonra veya şu anda başkaları için okumayı çok zorlaştırıyor.

Bunun bir yolu parametrelerinizi bir çeşit argüman sınıfına koymak olabilir. Daha sonra, değişkenlerin yalnızca bir alt kümesini (gerçekten 0 atamanıza eşdeğer) veya her bir platform için bu bağımsız değişken sınıfının farklı uzmanlıklarına sahip olabilirsiniz. Ancak buna değmeyebilir, uygun olup olmadığını analiz etmeniz gerekir.

İmkansız şablonları okuyabiliyorsanız, "Olağanüstü C ++" kitabında gelişmiş ipuçları bulabilirsiniz. Kodunuzu okuyan insanlar, bu kitapta öğretilen çılgın şeyleri kapsayacak şekilde becerilerini alabilirlerse, kolayca okunabilen güzel bir kodunuz olurdu. Derleyici aynı zamanda ne yaptığınızın da farkında olacaktır (önişleme yaparak her şeyi gizlemek yerine)

İlk olarak uyarı, başlık dosyasında değil kaynak dosyada değişken tanımıyla oluşturulur. API belgelerini oluşturmak için doxygen gibi bir şey kullanıyor olabileceğinizden, başlık bozulmamış kalabilir ve olmalıdır.

Kaynak dosyalarda tamamen farklı bir uygulamanız olduğunu varsayacağım. Bu durumlarda, rahatsız edici parametreyi yorumlayabilir veya yalnızca parametreyi yazabilirsiniz.

Misal:

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

Bu şifreli görünebilir, bu yüzden UNUSED gibi bir makro tanımladı. MFC'nin yaptığı gibi:

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

Bunun gibi hala hata ayıklama yapılarında uyarı görüyorsunuz, yardımcı olabilir.

Parametre adlarını her zaman yorumlamak güvenli değil mi? Eğer değilse, böyle bir şey yapabilirsiniz

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

Bu var biraz daha az çirkin.

(void)param2Uyarıyı susturmanın yolu yerine bunu gördüm :

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

Bunun C ++ 11'e eklendiği anlaşılıyor

Bir UNREFERENCED_PARAMETER(p)işe yarayabilir. Windows sistemleri için WinNT.h'de tanımlandığını ve gcc için de kolayca tanımlanabileceğini biliyorum (eğer zaten yoksa).

UNREFERENCED PARAMETER(p) olarak tanımlanır

#define UNREFERENCED_PARAMETER(P)          (P)

WinNT.h.

Derleyicinin bayrağını, örneğin GCC bayrağını kullanın: -Wno-unused-variable

__unusedDerleyiciye değişkenin kullanılamayabileceğini söylemek için kullanabilirsiniz .

- (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
}

C ++ 11, kullandığım çözüm bu:

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

Taşınabilir (en azından modern msvc, clang ve gcc'de) olduğu ve optimizasyonlar etkinleştirildiğinde fazladan kod üretmediği doğrulandı. Optimizasyon olmadan, ekstra işlev çağrısı gerçekleştirilir ve parametrelere referanslar yığına kopyalanır, ancak hiçbir makro yoktur.

Ek kod bir sorunsa, bu bildirimi kullanabilirsiniz:

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

ancak bu noktada bir makro daha iyi okunabilirlik sağlar:

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

Bu iyi çalışıyor ama C ++ 11 gerektirir

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

Sunulan cevapların çoğunun sadece yerel kullanılmayan değişken için çalıştığını ve kullanılmayan statik global değişken için derleme hatasına neden olacağını buldum.

Kullanılmayan statik genel değişken uyarısını bastırmak için başka bir makro gerekiyordu.

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

Anonim ad alanındaki statik olmayan genel değişken için hiçbir uyarı bildirilmediği için bu çalışır.

Yine de C ++ 11 gereklidir

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

Lol! Kaos tarafından bozulan tüm heretikleri bu kadar iyi ortaya koyan SO üzerinde başka bir soru olduğunu sanmıyorum!

C ++ 17'ye gereken tüm saygıyla birlikte, C ++ Temel Yönergeleri'nde açık bir kılavuz vardır . AFAIR, 2009'da bu seçenek bugün olduğu gibi mevcuttu. Ve eğer birisi Doxygen'te bir böcek olarak kabul edildiğini söylüyorsa, Doxygen'te bir böcek var

Uyarı ile ilgili sorununuzu görmüyorum. Xy derleyicisinin burada (doğru) bir uyarı vereceğini, ancak platform z için bu değişkenlerin gerekli olduğunu yöntem / işlev başlığında belgeleyin.

Uyarı doğrudur, kapatmanıza gerek yoktur. Programı geçersiz kılmaz - ancak bunun bir nedeni olduğu belgelenmelidir.