[g++] eliminare warning "unused parameter"

[trallallero]

Ho una miriade di warning del genere quando compilo ma non riesco a trovare il modo per sopprimere il messaggio.

-Wall mi serve perchè preferisco controllare tutti i warning, ma possibile che non si possa scegliere quali escludere ?

dal man g++:
-Wunused-parameter
Warn whenever a function parameter is unused aside from its declaration.

To suppress this warning use the unused attribute.

che significa "To suppress this warning use the unused attribute." ? :wtf:

[ilsensine]

Ho una miriade di warning del genere quando compilo ma non riesco a trovare il modo per sopprimere il messaggio.

-Wall mi serve perchè preferisco controllare tutti i warning, ma possibile che non si possa scegliere quali escludere ?
Non mi risulta che Wall implica anche Wunused-parameter.

che significa "To suppress this warning use the unused attribute." ? :wtf:
Che devi scrivere qualche schifezza illegibile tipo

#define __unused __attribute__((unused))

int ciao(__unused int x)
{
...
}

[ilsensine]

Nota che puoi anche omettere il nome dei parametri non usati, e anche in questo caso non viene emesso alcun warning:


int ciao(int, float, const double &)
{
return 0;
}

[trallallero]

Nota che puoi anche omettere il nome dei parametri non usati, e anche in questo caso non viene emesso alcun warning:


int ciao(int, float, const double &)
{
return 0;
}


si lo so, puoi anche castare a void il parametro


int ciao(int pippo)
{
(void)pippo;
return 0;
}

ma con 11.000 e più linee di codice non mi passa più ...

grazie comunque

[trallallero]

Non mi risulta che Wall implica anche Wunused-parameter.
uhm ... allora controllo meglio i flags che ho messo

Che devi scrivere qualche schifezza illegibile tipo

#define __unused __attribute__((unused))

int ciao(__unused int x)
{
...
}


:eek:

MAI!!! :D

[trallallero]

confermo, se tolgo -Wall sparisce

[ilsensine]

:eek:

MAI!!! :D
Invece il cast a void... :asd:

[ilsensine]

confermo, se tolgo -Wall sparisce
Allora aggiungi -Wno-unused-parameter dopo -Wall.

Per curiosità, quali sono i parametri completi che passi e che versione del gcc è?

[trallallero]

Invece il cast a void... :asd:

molto più elegante :O


scherzo eh :D

[trallallero]

Allora aggiungi -Wno-unused-parameter dopo -Wall.
provato ma c'è lo stesso

Per curiosità, quali sono i parametri completi che passi e che versione del gcc è?
uso g++

-DDEBUG -pipe -Wshadow -Woverloaded-virtual -Wold-style-cast -Wconversion -Wsign-compare -g -Wall -Wno-unused-parameter -W -D_REENTRANT -fpic $(DEFINES)

[ilsensine]

-W
Bestia, -W equivale a -Wextra :D
Metti -Wno-unused-parameter dopo -W (e cortesemente rinominalo nel suo vero nome, -Wextra ;) )

[trallallero]

Bestia, -W equivale a -Wextra :D
Metti -Wno-unused-parameter dopo -W (e cortesemente rinominalo nel suo vero nome, -Wextra ;) )

:stordita:

comunque funziona anche lasciando -W e mettendo -Wno-unused e l'ho scoperto da solo :O

ma ho corretto come dici tu per farti un piacere :O

grazie :D

[DanieleC88]

Ma ignorare il warning? :stordita:

[trallallero]

Ma ignorare il warning? :stordita:

senza il warning siamo intorno alle 150 righe di output del compilatore, con arriva a 500 ... fai un pò tu :D

[DanieleC88]

Se il compilatore ti dice troppo, forse il problema è alla radice... :p

No vabbe', se è così tanto grande l'output eliminalo pure.

[71104]

senza il warning siamo intorno alle 150 righe di output del compilatore, con arriva a 500 ... fai un pò tu :D cioè avete un numero di parametri inutilizzati che è più del triplo del numero di files sorgenti...? :stordita:
io cercherei di eliminare il warning agendo dai sorgenti, non dalla linea di comando :D :D

[ilsensine]

cioè avete un numero di parametri inutilizzati che è più del triplo del numero di files sorgenti...? :stordita:

Questa volta hai ragione :asd:

[DanieleC88]

Certo che ha ragione, sono stato io a notarlo! :O
Se il compilatore ti dice troppo, forse il problema è alla radice... :p

:Prrr:

[trallallero]

io cercherei di eliminare il warning agendo dai sorgenti, non dalla linea di comando :D :D

se dici così probabilmente non conosci il C++ :fiufiu:

[trallallero]

Questa volta hai ragione :asd:

ha ragione ? come fai/fate a sapere il numero dei miei sorgenti ? :mbe:

[kk3z]

ha ragione ? come fai/fate a sapere il numero dei miei sorgenti ?
forse perchè suppone che 150 righe di output = 150 file, se invece per ogni file compilato sono 150 righe di output, c'è qualcosa che non va :fagiano:

[DanieleC88]

se dici così probabilmente non conosci il C++ :fiufiu:
Perché? Allora non lo conosco neanche io...

[trallallero]

Perché? Allora non lo conosco neanche io...

questo è quello che produce doxygen dal progetto:
http://lh3.ggpht.com/trallallerotrallalla/R8_DP9xMhMI/AAAAAAAAAD8/UQijESsFjLE/s400/LL.jpg
(spero si veda l'immagine, ho usato gmail)

se nelle classi base prevedi che si possa usare una funzione piuttosto che un'altra
o che si possa usare in un modo piuttosto che in un altro,
avrai per forza di cose dei parametri che potrebbero, o non, essere utilizzati.

spiegato da cani ma devo ancora svegliarmi :stordita:

[DanieleC88]

Non si può fare dell'overloading o utilizzo di parametri opzionali?

[trallallero]

Non si può fare dell'overloading o utilizzo di parametri opzionali?

overloading ? e come ?

se fai una classe base dove prevedi che le classi derivate possano (non sono obbligate) usare una serie di parametri,
poi è impossibile usarli tutti per forza.

Per esempio nel mio sistema ho 3 parametri che devo portare appresso quasi ovunque perchè mi servono
per riempire una lista di eventi.
Ricevo un evento dall'esterno, scendo giù fino alla classe LLElement che potrebbe attivare qualcosa (p. es. accende un led -> evento)
e torno su fino al motore che legge gli eventi e li codifica per spedirli al chiamante.

Questi 3 parametri spesso non sono usati ed ecco spiegati i warnings ;)

[DanieleC88]

Non c'è modo di farli opzionali?
int MiaFunzione(Evento *primo, Evento *secondo = NULL, Evento *terzo = NULL)
{
if (secondo)
{
// ...
}
if (terzo)
{
// ...
}
}

Non conoscendo la struttura del tuo programma non posso ipotizzare altro... comunque, al limite puoi ignorarli, come detto prima. ;)

[71104]

http://lh3.ggpht.com/trallallerotrallalla/R8_DP9xMhMI/AAAAAAAAAD8/UQijESsFjLE/s400/LL.jpg in quello schema ci sono 23 classi, alle quali in teoria dovrebbero corrispondere altrettanti files sorgenti (estensione .cpp); se il vostro g++ produce 150 linee di output allora sicuramente oltre ai parametri inutilizzati c'è anche qualcos'altro che non va, perché ci sono 150-23=127 linee di troppo... :stordita:
fammi indovinare: scrivete tutti codice di merda e avete 127 warnings? :D :D :D
farete meglio a togliere quel -Wall, non fa proprio per voi poveri niubbetti :asd: :asd: :asd:

[trallallero]

in quello schema ci sono 23 classi, alle quali in teoria dovrebbero corrispondere altrettanti files sorgenti (estensione .cpp); se il vostro g++ produce 150 linee di output allora sicuramente oltre ai parametri inutilizzati c'è anche qualcos'altro che non va, perché ci sono 150-23=127 linee di troppo... :stordita:
fammi indovinare: scrivete tutti codice di merda e avete 127 warnings? :D :D :D
farete meglio a togliere quel -Wall, non fa proprio per voi poveri niubbetti :asd: :asd: :asd:
:doh:
dimenticavo che tu sei un utente Windows quindi al 99% non sai cos'è un makefile perchè ti basta premere http://www.cdjmerger.nl/images/play_button.jpg
per compilare :ciapet:

[71104]

:doh:
dimenticavo che tu sei un utente Windows quindi al 99% non sai cos'è un makefile perchè ti basta premere http://www.cdjmerger.nl/images/play_button.jpg
per compilare :ciapet: non mi prendere per il culo, da 23 righe non ci arrivi a 150 per colpa del makefile :asd:
voi avete una valanga di warning, di' la verità :ciapet:

PS: dal momento che in genere quando ci si va di linea di comando su Windows non si usare direttamente nmake ma build, mi piacerebbe poter dire di non conoscere i makefiles per nulla :ciapet: ma purtroppo non è così: col MinGW ci ho dovuto avere a che fare pure io :cry:

[trallallero]

non mi prendere per il culo, da 23 righe non ci arrivi a 150 per colpa del makefile :asd:
voi avete una valanga di warning, di' la verità :ciapet:

PS: dal momento che in genere quando ci si va di linea di comando su Windows non si usare direttamente nmake ma build, mi piacerebbe poter dire di non conoscere i makefiles per nulla :ciapet: ma purtroppo non è così: col MinGW ci ho dovuto avere a che fare pure io :cry:

dai che scherzavo :Prrr:

allora, visto che stiamo cercando il pelo nell'uovo, le linee sono esattamente 109 (con il -Wno-unused), i warnings 35 di cui 30 così:
/home/<trallallero>/workspace/<studente>.dev/src/nat/ConnGlobals.h:100: warning: declaration of ‘server_port’ shadows a member of 'this'
dove <studente> è uno studente quì che ha fatto la parte net del progetto.
gli altri 5 sono miei:
2 cosi:
control reaches end of non-void function
e stica visto che la funzione ha uno switch con case default quindi non c'è alcuna
end of non-void function

gli altri 3 (c'ho fatto caso adesso) son quegli strani warning quando dichiari membri nella classe in un certo ordine e poi li
inizializzi nel costruttore
: membro1(val), membro2(val), ...
in un ordine diverso

il mio codice è perfetto :O

:D


edit: comunque ogni warning potrebbe avere 2 righe ;)
/home/<trallallero>/workspace/<studente>.dev/src/nat/ConnGlobals.h: In constructor ‘OPEN_SOCKET:: OPEN_SOCKET(COMMON_SOCKET_TYPE, COMMON_ADDRESS_TYPE, COMMON_SOCKET_PROTOCOL, const char*, unsigned int)’:
/home/<trallallero>/workspace/<studente>.dev/src/nat/ConnGlobals.h:100: warning: declaration of ‘server_port’ shadows a member of 'this'

e, avendo fatto una cosa fatta bene, divisa in più directories, ogni volta che il make cambia dir ti
avverte -> = linea in più

[DanieleC88]

control reaches end of non-void function
e stica visto che la funzione ha uno switch con case default quindi non c'è alcuna
end of non-void function
Be', scusa, ma se hai una funzione tipo:
int MiaFunzione(int key)
{
switch (key)
{
case 0:
return ERRORE;
case 1:
return SUCCESSO;
default:
return SCONOSCIUTO;
}
}
allora puoi rendere felice gcc e chi leggerà il codice cambiandola in:
int MiaFunzione(int key)
{
switch (key)
{
case 0:
return ERRORE;
case 1:
return SUCCESSO;
}

return SCONOSCIUTO;
}

E magari usando qualche if. ;)

[trallallero]

Be', scusa, ma se hai una funzione tipo:
int MiaFunzione(int key)
{
switch (key)
{
case 0:
return ERRORE;
case 1:
return SUCCESSO;
default:
return SCONOSCIUTO;
}
}
allora puoi rendere felice gcc e chi leggerà il codice cambiandola in:
int MiaFunzione(int key)
{
switch (key)
{
case 0:
return ERRORE;
case 1:
return SUCCESSO;
}

return SCONOSCIUTO;
}

E magari usando qualche if. ;)

Così poi hai il warning sullo switch che non gestisce tutte le enum :asd:

ma si, un warning o 2 così non mi preoccupano, ma una miriade di "parameter not used" mi scocciano

grazie comunque :)

[kk3z]

Meglio ancora:
int MiaFunzione(int key)
{
int ret = 0;
switch (key)
{
case 0:
ret = ERRORE;
break;
case 1:
ret = SUCCESSO;
break;
default:
ret = SCONOSCIUTO;
break;
}
return ret;
}

Altrimenti con un distruttore inline e 3 return si espande ogni volta :)

[71104]

allora, visto che stiamo cercando il pelo nell'uovo, le linee sono esattamente 109 (con il -Wno-unused), i warnings 35 di cui 30 così:
/home/<trallallero>/workspace/<studente>.dev/src/nat/ConnGlobals.h:100: warning: declaration of ‘server_port’ shadows a member of 'this'
dove <studente> è uno studente quì che ha fatto la parte net del progetto. lo studente è una pippa: ha usato una naming convention ambigua :O

si dice peste e corna della notazione ungherese, ma non c'è niente da fare: quando si programma in C o in C++ è la migliore (in questo caso avrebbe evitato il warning).


Meglio ancora:
int MiaFunzione(int key)
{
int ret = 0;
switch (key)
{
case 0:
ret = ERRORE;
break;
case 1:
ret = SUCCESSO;
break;
default:
ret = SCONOSCIUTO;
break;
}
return ret;
}

Altrimenti con un distruttore inline e 3 return si espande ogni volta :) be' dai, ora ammetto di non aver mai analizzato il codice generato da un compilatore C++, ma se imposti un livello di ottimizzazione che prediliga il codice piccolo a quello veloce non credo che sia tanto fesso da non ottimizzare una cosa del genere :mbe:

[DanieleC88]

Così poi hai il warning sullo switch che non gestisce tutte le enum :asd:
Mica c'è l'obbligo di gestire ogni enumerazione? :wtf:

[71104]

Mica c'è l'obbligo di gestire ogni enumerazione? :wtf: no, ma doveva pur dire qualcosa per giustificarsi :)

[trallallero]

lo studente è una pippa: ha usato una naming convention ambigua :O
Veramente ha fatto un buon lavoro (per essere studente).
Per il resto io non ho tempo da perdere, non mi metto a correggere il codice altrui.
Se qualcosa va male ognuno ha le sue responsabilità.

Mica c'è l'obbligo di gestire ogni enumerazione? :wtf:

no, ma doveva pur dire qualcosa per giustificarsi :)

allora ditelo che non sapete programmare :asd:

dato questo esempio in un file test.c
#include <stdio.h>

typedef enum
{
A = 1,
B = 2,
C = 3,
} eXXX;

int main()
{
eXXX x = A;

switch (x)
{
case A:
break;
};

return 0;
}


<trallallero>@desktop:~/SRC/TEST$ g++ test.c -Wall
test.c: In function ‘int main()’:
test.c:14: warning: enumeration value ‘B’ not handled in switch
test.c:14: warning: enumeration value ‘C’ not handled in switch

ogni enum non gestita causa un warning :read:

[DanieleC88]

Perdonami, ma questa era del tutto gratuita, e te la potevi benissimo risparmiare: non conoscere a memoria tutti i warning di un compilatore non significa non saper programmare (e la mia era una domanda...).
Mi dimostri più che altro di essere tu quello che non ha idea della sintassi da rispettare (si vedano la virgola in eccesso dopo l'enumerazione della C e il punto e virgola inutile dopo il blocco dello switch), mi dimostri anche di non avere idea del fatto che se gcc vuole ricordare ai suoi utenti che un valore non è stato considerato in uno switch, non vuol dire che lo debbano fare tutti.

Provato giusto ora sotto il compilatore Microsoft, livello di warning massimo, nemmeno l'ombra di un errore segnalato:
#include <iostream>
using namespace std;

enum prova
{
A, B
};

void gestisci(enum prova);

int main()
{
gestisci(A);
gestisci(B);

#ifdef _WIN32
getchar();
#endif
return 0;
}

void gestisci(enum prova P)
{
switch (P)
{
case A:
cout << "Ciao" << endl;
break;
}
}
E leggo solo "Ciao" in output.

[trallallero]

Perdonami, ma questa era del tutto gratuita, e te la potevi benissimo risparmiare: non conoscere a memoria tutti i warning di un compilatore non significa non saper programmare (e la mia era una domanda...).
Mi dimostri più che altro di essere tu quello che non ha idea della sintassi da rispettare (si vedano la virgola in eccesso dopo l'enumerazione della C, si veda il punto e virgola inutile dopo il blocco dello switch), mi dimostri anche di non avere idea del fatto che se gcc vuole ricordare ai suoi utenti che un valore non è stato considerato in uno switch, non vuol dire che lo debbano fare tutti.

Provato giusto ora sotto il compilatore Microsoft, livello di warning massimo, nemmeno l'ombra di un errore segnalato:
#include <iostream>
using namespace std;

enum prova
{
A, B
};

void gestisci(enum prova);

int main()
{
gestisci(A);
gestisci(B);

#ifdef _WIN32
getchar();
#endif
return 0;
}

void gestisci(enum prova P)
{
switch (P)
{
case A:
cout << "Ciao" << endl;
break;
}
}
E leggo solo "Ciao" in output.
aoh, si scherza eh! mica sto facendo una gara a chi ne sa di più ;)

Con 71104 ci piamo sempre pel culo ma scherzosamente (io almeno) e io forse ho il difetto di essere troppo ironico e scherzo facendo finta di essere serio.

Per quanto riguarda l'esempio non è che mi son messo a scriverlo perfetto, era solo per far vedere che il gcc da un warning se non gestisci una enum, tutto quì.

Per quanto riguarda Windows ... beh ... questa è un'ulteriore dimostrazione che fa cagare :ciapet:



PS: la virgola dopo l'ultima enum è utilizzatissima invece, proprio in questo progetto l'ho usata in questo modo:
class LLBaseEntity
{
public:
...
typedef enum
{
#include "LLEntityTypes.def"
} LL_ENTITY_TYPE, LLET; //!< Entity types
...
};

e nel file incluso, se mi serve una nuova entità, aggiungo a fine riga:
Entità,
mi dirai che basterebbe scriverle così:
, Entità
ma cosa cambia ?

edit: e se proprio dovevi farmi notare un'errore, mica è il punto e virgola dopo la switch, ma il nome della enum ;)

[DanieleC88]

Ok ok freno anch'io e ti chiedo scusa per il tono... :)
mica sto facendo una gara a chi ne sa di più
Ecco, appunto per questo avevo scritto il post di prima. :D

D'oh, il mio commento non era riguardo al fatto che magari Windows faccia cagare (e se noti dalla mia firma sono un prode paladino del DebianClan, non sono certo a favore di Microsoft e famiglia :D), però era per fare un esempio su un diverso compilatore. Devo ammettere, nonostante tutto, che Visual Studio mi sta facendo una bella impressione... :stordita:

Per il fatto della virgola, be', al momento non l'ho nemmeno provata, ma ero certo che scrivere un'enumerazione in quel modo generasse un errore (ergo: mi ricordo in passato di aver fatto anch'io una cosa simile, ma con poca felicità di gcc, magari con gcc 4.x funziona).

ciao ;)

[trallallero]

Ok ok freno anch'io e ti chiedo scusa per il tono... :)
capirai, scusa a te se son sembrato "in guerra" :)

D'oh, il mio commento non era riguardo al fatto che magari Windows faccia cagare (e se noti dalla mia firma sono un prode paladino del DebianClan, non sono certo a favore di Microsoft e famiglia :D), però era per fare un esempio su un diverso compilatore. Devo ammettere, nonostante tutto, che Visual Studio mi sta facendo una bella impressione... :stordita:
Ma si, io dico che fa cagare perchè non sono abituato ad usarlo per lavoro.
Ma quelli che conosco che sanno usare sia Linux che Windows sono totalmente a favore di Linux, con Windows non sono a loro agio.
Per il resto Windows è indispensabile per i media, purtroppo se fai musica col PC e vuoi roba professionale Linux fa cagare.

Per il fatto della virgola, be', al momento non l'ho nemmeno provata, ma ero certo che scrivere un'enumerazione in quel modo generasse un errore (ergo: mi ricordo in passato di aver fatto anch'io una cosa simile, ma con poca felicità di gcc, magari con gcc 4.x funziona).

ciao ;)
Mi sembra proprio di si, anche a me ricordo che dava errore quando incrementavo la enum col copia incolla e puntualmente
dimenticavo di cancellare la virgola.
Forse qualcuno nel gcc staff c'è passato e ha deciso di eliminare l'errore :D

ciao :)

[cdimauro]

D'oh, il mio commento non era riguardo al fatto che magari Windows faccia cagare (e se noti dalla mia firma sono un prode paladino del DebianClan, non sono certo a favore di Microsoft e famiglia :D), però era per fare un esempio su un diverso compilatore.
D'altra parte sono cose non contemplate dallo standard C++: ogni compilatore si regola come crede meglio coi warning.
Devo ammettere, nonostante tutto, che Visual Studio mi sta facendo una bella impressione... :stordita:
Perché si tratta di un ottimo prodotto, anche se... gira solo sotto Windows. :cool:

x trallallero: non sapevo che Windows fosse un compilatore... :asd: :read: :Prrr:

[trallallero]

x trallallero: non sapevo che Windows fosse un compilatore... :asd: :read: :Prrr:

lo sai bene che sfrutto ogni occasione per far notare quanto fa schifo il vostro Winzozz :ciapet:

[71104]

lo sai bene che sfrutto ogni occasione per far notare quanto fa schifo il vostro Winzozz :ciapet: in teoria allora dovresti stare sempre zitto :Prrr:

[71104]

Per il fatto della virgola, be', al momento non l'ho nemmeno provata, ma ero certo che scrivere un'enumerazione in quel modo generasse un errore e invece guarda ti dirò, la virgola di troppo mi sembra una feature del linguaggio addirittura estremamente utile! una mano santa tutte le volte che devo inizializzare matrici di grosse dimensioni dai dati molto simili: posso scrivere tutte le righe (compresa l'ultima) con un copia incolla e fare solo piccole modifiche. non che ci voglia molto a dir la verità a cancellare l'ultima virgola se proprio proprio, però è comoda :D io la lascio sempre.

edit - tra l'altro credo che costituisca una comoda semplificazione anche per quei software che devono generare codice C o C++.

[DanieleC88]

D'altra parte sono cose non contemplate dallo standard C++: ogni compilatore si regola come crede meglio coi warning.
Era proprio per quello. :)

[DanieleC88]

e invece guarda ti dirò, la virgola di troppo mi sembra una feature del linguaggio addirittura estremamente utile!
Ve bene, ho capito, mi ritiro nell'angolo della mia ignoranza... :cry:

:Prrr:
Ok, ora mi avete messo la curiosità e vado a provarlo! :D

EDIT: appena provato su gcc, ed effettivamente funziona... :ops:

[cdimauro]

in teoria allora dovresti stare sempre zitto :Prrr:
* :D
e invece guarda ti dirò, la virgola di troppo mi sembra una feature del linguaggio addirittura estremamente utile! una mano santa tutte le volte che devo inizializzare matrici di grosse dimensioni dai dati molto simili: posso scrivere tutte le righe (compresa l'ultima) con un copia incolla e fare solo piccole modifiche. non che ci voglia molto a dir la verità a cancellare l'ultima virgola se proprio proprio, però è comoda :D io la lascio sempre.

edit - tra l'altro credo che costituisca una comoda semplificazione anche per quei software che devono generare codice C o C++.
Lo è. Ed è... Python style. :p