[g++] eliminare warning "unused parameter"

[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

[DanieleC88]

Originariamente inviato da trallallero

se dici così probabilmente non conosci il C++

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

[trallallero]

Originariamente inviato da DanieleC88

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

questo è quello che produce doxygen dal progetto:

(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

[DanieleC88]

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

[trallallero]

Originariamente inviato da DanieleC88

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]

Originariamente inviato da 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...
fammi indovinare: scrivete tutti codice di merda e avete 127 warnings?
farete meglio a togliere quel -Wall, non fa proprio per voi poveri niubbetti

[trallallero]

Originariamente inviato da 71104

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...
fammi indovinare: scrivete tutti codice di merda e avete 127 warnings?
farete meglio a togliere quel -Wall, non fa proprio per voi poveri niubbetti

dimenticavo che tu sei un utente Windows quindi al 99% non sai cos'è un makefile perchè ti basta premere
per compilare

[71104]

Originariamente inviato da trallallero

dimenticavo che tu sei un utente Windows quindi al 99% non sai cos'è un makefile perchè ti basta premere
per compilare

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

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 ma purtroppo non è così: col MinGW ci ho dovuto avere a che fare pure io

[trallallero]

Originariamente inviato da 71104

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

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 ma purtroppo non è così: col MinGW ci ho dovuto avere a che fare pure io

dai che scherzavo

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




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]

Originariamente inviato da trallallero

 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]

Originariamente inviato da DanieleC88

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

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]

Originariamente inviato da trallallero

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

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

Originariamente inviato da 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

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

[DanieleC88]

Originariamente inviato da trallallero

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

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

[71104]

Originariamente inviato da DanieleC88

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

no, ma doveva pur dire qualcosa per giustificarsi

[trallallero]

Originariamente inviato da 71104

lo studente è una pippa: ha usato una naming convention ambigua

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à.

Originariamente inviato da DanieleC88

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

Originariamente inviato da 71104

no, ma doveva pur dire qualcosa per giustificarsi

allora ditelo che non sapete programmare

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

[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]

Originariamente inviato da 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, 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



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'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 ), però era per fare un esempio su un diverso compilatore. Devo ammettere, nonostante tutto, che Visual Studio mi sta facendo una bella impressione...

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