Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Stavo cercando di aggiungere le funzioni template all'insieme delle mie (limitate) conoscenze, ma mi trovo di fronte a una cosa che non riesco a capire da solo. Ho già provato ad aggiungere un paio di bicchieri di buon rosso per rafforzare la capacità d'introspezione ma niente da fare -- il mistero non si dipana. Prima di cadere nella spirale senza fine dell'alcolismo provo a chiedere il vostro prezioso aiuto. La questione è questa...
Perché diavolo la funzione template CompattaArray() in questo codice funziona per i valori double e int e non per le stringhe const char * ?
Codice sorgente - presumibilmente C++
#include <stdio.h>
#include <string.h>
template<class tipo>// prototipo della funzione template
unsignedint CompattaArray( tipo *a, unsignedint totEl,
unsignedint CompattaArray( tipo *a, unsignedint totEl,
bool fNullita(tipo*),
const tipo *nullo ){
unsignedint i, j;
for( i=j=0; i<totEl;++i )
if(!fNullita(&(a[i])))
a[j++]= a[i];
if( nullo )
for( i=j; i<totEl;++i )
a[i]=*nullo;
return j;// la quantita' degli elementi non nulli
// "raggruppati" in testa all'array
}
bool CondizioneNullitaPtr(constchar*e ){
// CompattaArray() elimina tutti i puntatori NULL
return e ==NULL;
}
bool CondizioneNullitaDouble(double*e ){
// CompattaArray() elimina tutti i valori inferiori a 0.5
return*e <0.5;
}
bool CondizioneNullitaInt(int*e ){
// CompattaArray() elimina tutti i valori non compresi tra 5 e 10
return*e < 5 ||*e >10;
}
Il compilatore mastica tutto, quindi sputa fuori questa odiosa raffica di sentenze, secondo me con la chiara intenzione di denigrare i miei sforzi con una palese dose di sadismo:
||=== Build: Release in Prova fTemplate (compiler: GNU GCC Compiler) ===|
\main.cpp||In function 'int main()':|
\main.cpp|23|error: no matching function for call to 'CompattaArray(const char* [6], const unsigned int&, bool (&)(const char*), const char**)'|
\main.cpp|23|note: candidate is:|
\main.cpp|5|note: template<class tipo> unsigned int CompattaArray(tipo*, unsigned int, bool (*)(tipo*), const tipo*)|
\main.cpp|5|note: template argument deduction/substitution failed:|
\main.cpp|23|note: deduced conflicting types for parameter 'tipo' ('const char*' and 'const char')|
||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===|
(Ho eliminato tutti i riferimenti al percorso del file main.cpp, per sintetizzare, tanto sono irrilevanti in questo contesto.)
Credo che la chiave possa essere in quel conflicting types for parameter 'tipo', ma non capisco da cosa possa nascere il conflitto. Il compilatore non dovrebbe sostituire "tipo" con "const char*" e accettare aPtr (l'array di stringhe const char* in main) come un puntatore ad un array di const char*, ovvero come tipo* ? Non dovrebbe valere la stessa cosa anche per nPtr? No, pare proprio di no, ma non capisco perché. Sto già versando il terzo bicchiere di rosso.
ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
Non credo che troverebbe differenze tra un puntatore che punta a un array di char e un puntatore che punta ad un array di int o di double. Le apparenze mi portano a ipotizzare che la soluzione sia nascosta da qualche parte nel modo in cui viene interpretato il puntatore che punta a un array di puntatori a (const) char...
Edit: Ho effettivamente provato, il codice che segue funziona benissimo.
Codice sorgente - presumibilmente C++
#include <stdio.h>
#include <string.h>
template<class tipo>// prototipo della funzione template
unsignedint CompattaArray( tipo *a, unsignedint totEl,
bool fNullita(tipo*),
const tipo *nullo =NULL);
// prototipi delle funzioni di verifica
// delle condizioni di nullita' (esempi)
bool CondizioneNullitaChar(char*e );
int main(){
constunsignedint totEl =6;
unsignedint nElValidi =0;
// tutti i valori non compresi tra 'c' e 'f' vengono "cassati";
unsignedint CompattaArray( tipo *a, unsignedint totEl,
bool fNullita(tipo*),
const tipo *nullo ){
unsignedint i, j;
for( i=j=0; i<totEl;++i )
if(!fNullita(&(a[i])))
a[j++]= a[i];
if( nullo )
for( i=j; i<totEl;++i )
a[i]=*nullo;
return j;// la quantita' degli elementi non nulli
// "raggruppati" in testa all'array
}
bool CondizioneNullitaChar(char*e ){
// CompattaArray() elimina tutti i valori non compresi tra 'c' e 'f'
return*e <'c'||*e >'f';
}
Ultima modifica effettuata da AldoBaldo il 06/11/2015 alle 13:52
ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
Usi l'operatore di stringa " per un array di caratteri : che usano l'operatore '. Per fare "a", "b" to serve const char **lista non char *lista. Inoltre specificare il numero di elementi mentre inizializzi un array è una pratica abbastanza discutibile.
Nei termini dell'errore che ho illustrato originariamente non cambia nulla, non credo proprio che l'errore sia lì.
L'aggiunta esplicita della quantità degli elementi dell'array è una scelta che ho fatto perché, siccome sto "sperimentando", volevo essere sicuro di non incorrere in errori nella quantificazione degli elementi nelle varie prove.
Ultima modifica effettuata da AldoBaldo il 06/11/2015 alle 14:13
ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
Lumo hai definito la funzione condizione nullità ptr perché la funzione funzionava con un solo puntatore e non un puntatore a puntatore? O ci sono modifiche che mi sfuggono?
Lumo, mi fai fare la figura del pirla, e me lo merito. A una funzione che accetta un puntatore a puntatore passo l'indirizzo a un puntatore "semplice" e manco me ne accorgo pur guardando, e riguardando, e riguardando ancora. Robe da chiodi. Prosciutto sugli occhi. Che vergogna! Be', me la cavo come al solito: facendo notare la firma in calce a ciascuno dei miei messaggi.
Ora funziona tutto a dovere.
Grazie davvero per la guida che mi offrite (tu e gli altri) nell'orientarmi in questo mio hobby.
P.S. Ero disperato, perché ormai avevo già finito la terza bottiglia di rosso... purtuttavia continuavo a non ricavarne nessuna illuminazione.
PP.SS. Non è vero, non mi sono pippato così tanto rosso... però dirlo fa tanto "colore"!
Ultima modifica effettuata da AldoBaldo il 07/11/2015 alle 15:12
ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.