Puntatori a Funzione[C]

[ienaplinsky]

Esatto
Comunque non ti abbattere, il C è un linguaggio terribile per chi è alle prime armi anche io lo stuidiai come primo linguaggio e non sapevo nemmeno cosa era il sistema numerico binario insomma non avevo mai messo le mani su un sorgente.Ora non sono un esperto ma i concetti base li ho assimilati, ci vuole solo un po di tempo

[matteovid]

Ciao Gila

bravo per il tuo esempio

adesso prova sempre dal tuo esempio a fare che dal main chiami una funzione che ha tutti i parametri della main originale.

es:

Codice: Seleziona tutto

int  main()
{
   
    void (*ptr)(CALL)=stampa_1;
    void  (*ptr_2)(void)=stampa_2;
    (*ptr)(ptr_2);
    printf ("indirizzo stampa_2 %p\n",stampa_2);
    printf ("indirizzo *ptr_2 %p\n",ptr_2);
   
    return 0;
}

diventa:

Codice: Seleziona tutto

void Gila()
{
   
    void (*ptr)(CALL)=stampa_1;
    void  (*ptr_2)(void)=stampa_2;
    (*ptr)(ptr_2);
    printf ("indirizzo stampa_2 %p\n",stampa_2);
    printf ("indirizzo *ptr_2 %p\n",ptr_2);
}

int main ()
{
    Gila();
    return 0;
}

noti delle problematiche, o degli errori.

cosa intendi tu per puntatore a puntatore.

poi dal mio esempio del mio ultimo post, prova a fare l'esercizio che ti ha detto vbextreme.
In pratica è quello che mi hanno fatto fare a scuola, prima l'esempio che ti ho lasciato, poi dopo i passaggi per metterlo su diversi file e costruirsi il makefile, sono arrivato a quello che chiede vbextreme, tutto in 4 ore... tu devi capire bene, quindi prendila con calma e sopratutto non avvilirti, il C è meraviglioso ma anche tanto diffidente le prime volte

Matteo

[matteovid]

Esatto
Comunque non ti abbattere, il C è un linguaggio terribile per chi è alle prime armi anche io lo stuidiai come primo linguaggio e non sapevo nemmeno cosa era il sistema numerico binario insomma non avevo mai messo le mani su un sorgente.Ora non sono un esperto ma i concetti base li ho assimilati, ci vuole solo un po di tempo

Esattamente.

io sono elettronico (perito) e al giorno d'oggi se non sai il C e assembler non combini niente, da quando sono all'università sto imparando a programmare in C e assembler, continuando a studiare elettronica sia digitale che analogica

[vbextreme]

Mi sa che io erroneamente ragiono in termini di variabili, ma qui si ha a che fare con funzioni e la cosa funziona diversamente

Il problema è che finora hai usato i puntatori ma realmente non hai capito cosa sono,un puntatore classico e uno a funzione lavorano grosso modo nella stessa maniera.

Proviamo a chiarire il concetto e per fare ciò ci inventiamo un fantacomputer,questo fantacomputer avrà una fantacpu e una fantamemoria.
La memoria sarà come un enorme vettore in base 0,avremo quindi:

MEM[0] == prima cella di memoria
MEM[LAST] == ultima cella di memoria

La fantacpu invece eseguirà dei comandi contenuti nella memoria stessa,partendo esattamente dalla cella 0 della memoria leggerà ed eseguirà il comando.
Il primo problema è dove posizionare le variabili,dato lo scorrimento verso il basso della cpu sulla memoria potrebbero esserci collisioni,allora noi mettiamo le variabili a partire dal fondo della memoria.
Quindi se noi scrivessimo in c questa riga:

Codice: Seleziona tutto

int A = 10;

il nostro fantacompilatore farà:

Codice: Seleziona tutto

//LAST == offset A
MEM[LAST] = 10;

ricordandosi che la variabile A è contenuta nell'offset LAST
ma se noi adesso scriviamo

Codice: Seleziona tutto

int* B = &A;

Il nostro fanta compilatore farà:

Codice: Seleziona tutto

//LAST == offset A
//LAST-1 == offset B;
MEM[LAST-1] = LAST;

Salvando dentro la cella indirizzata da B l'offset della cella A.
Ora se noi scriviamo:

Codice: Seleziona tutto

int a = 10;
int* b = &a;
int c;
c = a + *b;

Il nostro amicone farà:

Codice: Seleziona tutto

//CURRENT = 0 == Offset codice in memoria
//LAST == offset A
//LAST-1 == offset B;
//LAST-2 == offset C;

MEM[LAST] = 10; // int a = 10;
MEM[LAST-1] = LAST; // int* b = &a;
MEM[CURRENT++] ={  MEM[LAST-2] = ADDIZIONA( MEM[LAST], MEM[MEM[LAST-1]]) }; // c = a + *b;

Analizziamo l'ultima riga:
Inanzitutto Salviamo nella cella "MEM[CURRENT]"(current parte da 0 dato che la fcpu parte ad eseguire il codice da 0) l'operazione che vogliamo eseguire.
L'operazione è racchiusa tra le graffe.
Nel nostro caso memorizzo che devo fare un'addizione tra due celle di memoria e salvare il risultato nella cella LAST-2 che sarà l'offset di c.
Nel primo parametro il fantacompilatore passa direttamente il contenuto della cella di memoria tramite "MEM[LAST]",nel secondo caso invece gli abbiamo detto che il valore nella cella è un puntatore tramite * e quindi il fantacompilatore andrà ad accedere a tale memoria.
Ottenendo cosi:
MEM[MEM[LAST-1]] -> MEM[last] -> 10
Se non avremmo scritto l'asterisco allora il fantacompilatore avrebbe scritto la riga cosi:

Codice: Seleziona tutto

MEM[CURRENT++] ={  MEM[LAST-2] = ADDIZIONA( MEM[LAST], MEM[LAST-1]) }; // c = a + b;

ottenendo per il secondo parametro un valore di:
MEM[LAST-1] -> LAST
Mettiamo il caso che LAST valga mille e quindi abbiamo 1000 celle di memoria avremmo ottenuto un'addizione di 10+1000 e non 10+10.

Ecco spiegato il concetto di puntatore.
Ora noi possiamo creare tanti puntatori quanti ne vogliamo es:

Codice: Seleziona tutto

int A = 10;
int* B = &A;
int** C = &B;
int*** D = &C;
int**** E = &D;

Codice: Seleziona tutto

//LAST == offset A
//LAST-1 == offset B;
//LAST-2 == offset C;
//LAST-3 == offset D;
//LAST-4 == offset E;

MEM[LAST] = 10; // int a = 10;
MEM[LAST-1] = LAST; // int* b = &a;
MEM[LAST-2] = LAST - 1; // int** c  = &b;
MEM[LAST-3] = LAST - 2; // int*** d  = &c;
MEM[LAST-4] = LAST - 3; // int**** e  = &d;

Se volessimo il valore puntato da "E" ovvero (A==10) dovremmo fare:

Codice: Seleziona tutto

MEM[ MEM[ MEM[ MEM[ MEM[LAST-4] ] ] ] ];

come vedi il meccanismo rimane identico.

Per i puntatori a funzione avviene la stessa identica cosa ma un pelo diversa.
Come già detto la nostra cpu esegue i comandi contenuti in memoria e nel nostro semplice esempio nella cella MEM[0] ci abbiamo messo un'addizione.Appena partirà la cpu eseguirà direttamente quel comando e proseguirà con i sucessivi comandi.
Ora mettiamo il caso che la cpu possa eseguire il comando SALTA, questo comando gli fa continuare il lavoro in un'altra area della memoria,potremmo quindi ad esempio memorizzare nella cella MEM[500] una funzione che ne so Pippo().
Il codice:

Codice: Seleziona tutto

void Pippo(void)
{
    ++c;
}

int a = 10;
int* b = &a;
int c = a + *b;
Pippo();

Codice: Seleziona tutto

//CURRENT = 0 == Offset codice in memoria
//LAST == offset A
//LAST-1 == offset B;
//LAST-2 == offset C;
//Pippo == 500

MEM[LAST] = 10; // int a = 10;
MEM[LAST-1] = LAST; // int* b = &a;
MEM[CURRENT++] ={  MEM[LAST-2] = ADDIZIONA( MEM[LAST], MEM[MEM[LAST-1]]) }; // c = a + *b;
MEM[CURRENT++] ={  SALTA(500) }; //Pippo()

MEM[500] = { MEM[LAST-2] = ADDIZIONA( MEM[LAST-2] , 1) ; // void Pippo(void){ ++c;}

Quindi dopo la prima addizione mettiamo il comando SALTA alla cella 500 che conterrà la nostra funzione che somma 1 a C.

Ora ecco cosa succede se noi mettiamo un puntatore a funzione sul nostro fantacomputer

Codice: Seleziona tutto

void Pippo(void)
{
    ++c;
}

int a = 10;
int* b = &a;
int c = a + *b;
void(*PIPPO)(void) = Pippo;
PIPPO();

Codice: Seleziona tutto

//CURRENT = 0 == Offset codice in memoria
//LAST == offset A
//LAST-1 == offset B;
//LAST-2 == offset C;
//LAST-3 == offset puntatore a funzione PIPPO
//Pippo == 500

MEM[LAST] = 10; // int a = 10;
MEM[LAST-1] = LAST; // int* b = &a;
MEM[CURRENT++] ={  MEM[LAST-2] = ADDIZIONA( MEM[LAST], MEM[MEM[LAST-1]]) }; // c = a + *b;

MEM[LAST-3] = 500; // void(*PIPPO)(void) = Pippo;
MEM[CURRENT++] ={  SALTA(MEM[LAST-3]) }; //PIPPO()

MEM[500] = { MEM[LAST-2] = ADDIZIONA( MEM[LAST-2] , 1) ; // void Pippo(void){ ++c;}

Come vedi in questo caso invece di mettere il valore dell'offset della cella di Pippo ci mettiamo un'area della memoria che punta a quell'indirizzo.In questo modo quando il comando legge la cella LAST-3 leggerà 500 ovvero l'offset di Pippo.
Come vedi funziona alla stessa maniera dei puntatori normali.
Col nostro fantacomputer avremmo potuto fare anche

Codice: Seleziona tutto

void* fp = 500;
void(PIPPO)(void) = fp;
PIPPO();

Codice: Seleziona tutto

MEM[LAST-4] = 500;
MEM[LAST-3] = MEM[LAST-4];
MEM[CURRENT++] = { SALTA(MEM[LAST-3]) }

Usiamo dunque un puntatore a funzione quando vogliamo saltare all'interno della cella a cui punta la variabile PIPPO, ma non possiamo usare direttamente il puntatore void* fp perchè altrimenti il compilatore non saprebbe come comportarsi.
Ora quindi il discorso di * ** *** **** ***** è identico al codice spiegato con le variabili,solo che sarà inserito all'interno di SALTA. tutto qui.

Se sei riuscito a capire questo fantacomputer allora sei molto vicino a capire come lavora realmente un microprocessore e la sua ram.
Solo che in questo caso una realecpu = fantacpu * difficoltà ^ 1000; tutto qui.

[gila75]

Il problema è che finora hai usato i puntatori ma realmente non hai capito cosa sono,un puntatore classico e uno a funzione lavorano grosso modo nella stessa maniera.

Mi auguro che non sia proprio così
la confusione nasce dopo le liste ho iniziato a passare un puntatore in modo errato.
Nelle liste, come dicevamo si usa un doppio puntatore, per motivi particolari.
Invece per passare un puntatore, non è necessario usare **
Modo errato:

Codice: Seleziona tutto

  
#include <stdlib.h>
  #include <stdio.h>

void prova (int **copy_p)
{
      printf ("valore di *p %d\n",**copy_p);
      return ;
 }


int  main()
     {
       
       int a=10;
       int *p=&a;
       prova (&p);
       return 0;
    }

Modo corretto:

Codice: Seleziona tutto

   

 #include <stdlib.h>
 #include <stdio.h>
void prova (int *copy_p)
{
      printf ("valore di *p %d\n",*copy_p);
      return ;
 }


int  main()
     {
       
       int a=10;
       int *p=&a;
       prova (p);
       return 0;
    }

il primo esempio (puntatore a puntatore), dovrebbe essere usato, quando vogliamo passare un puntatore, e contemporaneamente
avere un puntatore che possa modificare....grosso modo.
Il secondo esempio invece, passa semplicemente un puntatore.
Credo che tutta la confusione nasca da li.
Non dico di padroneggiare i puntatori, quello no, ma penso di aver capito un po.
Rileggo bene però la tua spiegazione Vbextreme.

[matteovid]

ciao Gila

la confusione nasce dopo le liste ho iniziato a passare un puntatore in modo errato.
Nelle liste, come dicevamo si usa un doppio puntatore, per motivi particolari.

mi sono perso, si parlava di puntatori a funzione, adesso parli di liste e doppio puntatore per motivi particolari...

non capisco....

comunque @vbextreme ti ha spiegato in modo comprensibile e semplice i puntatori...

se vuoi spiegare le liste che usano doppi puntatori per motivi particolari, o almeno dove lo hai letto, te ne sarei grato, grazie

Matteo

[antex]

Mi sa che io erroneamente ragiono in termini di variabili, ma qui si ha a che fare con funzioni e la cosa funziona diversamente

Il problema è che finora hai usato i puntatori ma realmente non hai capito cosa sono,un puntatore classico e uno a funzione lavorano grosso modo nella stessa maniera.

Secondo me invece, nei casi pratici, conviene pensare i puntatori a funzione in maniera particolare, non come i puntatori "normali", ma piuttosto come degli alias. Si può "giocare" a deferenziarli eccetera, ma concretamente non serve quasi mai.

Gila, non ti scervellare, e usa questa notazione semplice:

Codice: Seleziona tutto

#include <stdio.h>

void stampa(int x) {
    printf("%d\n", x);
}

int main() {
    void (*punt)(int x);

    punt = stampa;
    punt(2);

    return 0;
}

senza * né &.

Se invece ti vuoi sbronzare i neuroni puoi pure cercare di capire perché questo codice funziona:

Codice: Seleziona tutto

#include <stdio.h>

void stampa(int x) {
    printf("%d\n", x);
}

int main()
{
    void (*punt)(int x);

    punt = &stampa;
    punt = *stampa;
    punt = **stampa;
    punt = *punt;
    punt = ****punt;
    punt = *****punt;

    (*stampa)(2);
    (**stampa)(2);
    (***punt)(2);
    (****punt)(2);
    (*****punt)(2);

    return 0;
}

e questo no: punt = &punt.

[gila75]

mi sono perso, si parlava di puntatori a funzione, adesso parli di liste e doppio puntatore per motivi particolari...

Infatti si parla ancora di quello
Il discorso delle liste non c'entra nulla. Dicevo solo che per le liste e in determinati casi si usa **.
Quindi mi sono confuso e li ho usati erroneamente per passare un puntatore a funzione.
Hai visto i due esempi che ho postato?
Uno era sbagliato (quello che usavo).
tutto il casino, discusso con vbextreme, è che usavo ** anche se non era necessario...ora ho capito

@antex, io preferisco così, più compatto.
Quello da te proposto, è a mio modo il modo più diretto e chiaro (mia opinione)

Codice: Seleziona tutto

#include <stdio.h>
 #include <stdlib.h>

    void stampa(int x) {
        printf("%d\n", x);
    }

    int main() {
        void (*punt)(int x)=stampa;
        punt(2);
        return 0;
    }

@matteovid

se vuoi spiegare le liste che usano doppi puntatori per motivi particolari, o almeno dove lo hai letto, te ne sarei grato, grazie

non sono sul mio pc...appena posso lo posto.
Oppure nella discussione studio liste ci sono esempi postati da me

[vbextreme]

tutto il casino, discusso con vbextreme, è che usavo ** anche se non era necessario...ora ho capito

Sicuro?
Il piu grande errore che fatto tutti gli "esordienti" del c è il non capire che il parametro di una funzione è una nuova variabile sempre e comunque.
Quindi:

Codice: Seleziona tutto

void Pippo(int* P);
...
int A = 10; // indirizzo di a = 0x0000 
int* B = &A; // &b = 0x0001 b =0x0000 *b = 10

void Pippo(B);
...
void Pippo (int* P)
{
    *P = 100; //&P = 0x0002 quindi è una nuova variabile, P = 0x0000 che punta dove punta B, *P = 10 lo stesso valore di b dato che puntano allo stesso oggetto.
}

Ora se io volessi cambiare da dentro la funzione l'area puntata da B tramite il parametro P non potrei farlo,perchè in nessun modo con questa tecnica posso accedere al valore di B. Pertanto passo l'indirizzo di B quindi essendo B un puntatore lo sommo e diventa **

Codice: Seleziona tutto

void Pippo(int** P);
...
int A = 10; // indirizzo di a = 0x0000 
int* B = &A; // &b = 0x0001 b =0x0000 *b = 10

void Pippo(&B);
...
void Pippo (int** P)
{
    *P = 100; //&P = 0x0002 quindi è una nuova variabile, P = 0x0001 che punta alla memoria di  B, *P = 0x0000 è la variabile puntata da B ovvero A.
    //con questa linea dunque A non diventerà 100 ma B andrà a puntare alla locazione 100 della memoria causando molto probabilmente un grosso guaio.
}

Ora il discorso coi puntatori a qualsiasi cosa il discorso non cambia.
L'unico caso particolare è con quelli a funzione,perchè bisogna informare il compilatore che deve eseguire particolari procedure,ma a noi poco cambia , il puntatore a funzione si riferirà sempre ad un'area della memoria come un puntatore a intero o a qualsiasi altra cosa.
Ovvio non bisogna troppo soffermarsi sulle virgole ma il concetto fondamentalmente è questo.
Cerca di capirlo cosi e di proseguire,solo alla fine dello studio sul linguaggio e durante i vari esercizi imparerai poi realmente il mondo dei puntatori.

[gila75]

Sicuro?

Sicuro no, non ho questa presunzione...ho tanto da imparare
Credo di aver capito cosa sbagliavo...passavo un puntatore a funzione col doppio **.
Il compilatore non dava nemmeno un warning ma di fatto è superfluo.
Avevo parlato con te vbextreme del discorso delle liste quando passi la testa e usi il doppio **
Ma li è diverso, lo sai meglio di me, li è necessario.

Ovvio non bisogna troppo soffermarsi sulle virgole ma il concetto fondamentalmente è questo.
Cerca di capirlo cosi e di proseguire,solo alla fine dello studio sul linguaggio e durante i vari esercizi imparerai poi realmente il mondo dei puntatori.

Sicuramente! Solo col tempo e molti e molti esercizi si può capire a fondo, assimilare i vari concetti.
Quindi qualcosa va tralasciato per poi riprenderlo in futuro. Il difficile è capire quando è il caso di approfondire e quando lasciare.
Comunque vado avanti a studiare i vari esempi che tu e altri avete postato.
E come sempre grazie

[matteovid]

Ciao Gila

[OT
ho letto il thread sulle liste...

in pratica tutto quel thread si risolve con solo la visualizzazione di una lista....
che la lista e quello che contiene lo metti tu come costante... facile ma che per capire non serve a nulla...
Bastava crearsi una funzione inserimento, una funzione delete, una funzione visualizza...
tutto gestito da un menù il più semplice possibile...

Codice: Seleziona tutto

1] inserisci
2] cancella
3] visualizza
q] esci

poi che siano liste semplici o con doppia chiave o quello che vuoi, ti sei incapunito sui nodi e sul nodo fittizio...

come pensavo non hai appreso la praticità delle funzioni, nè dei loro parametri,
che siano char numeri array pointer function pointer address, pointer normali, nè il ritorno delle funzioni....

e ancora più grave nemmeno i puntatori, almeno a che servono.... nella praticità...
[/OT]

ed anche in questo thread oltre al main e due funzioni non vai...

Contento tu, contenti tutti

Matteo

[gila75]

Nelle liste avevo fatto tutto quel "giro" perchè sul mio manuale era tutto dichiarato al di fuori del main.
E quindi tutte le funzioni erano senza argomenti, non si passava nulla.
void stampa()
void stampa_reverse()
ecc...
Allora avevo implementato i passaggi a funzione.
Sinceramente in quella discussione, nessuno aveva detto che le funzioni, gli argomenti e i puntatori erano sbagliati...mi giunge nuova.
Comunque ora questa discussione, aveva preso un bivio: capire il perchè io passavo un puntatore a funzione col **
Quando invece non è necessario.
L'esempio di un puntatore passato a funzione l'ho postato qualche messaggio fa se hai notato.
Continuo a insistere che era questo il dilemma suscitato (a ragione da Vbextreme). Ora ho visto che il ** non è necessario.
Comunque se dici che non ci ho capito nulla, è inutile andare avanti e farvi perdere tempo...lasciamola in sospeso
Grazie comunque a tutti per l'aiuto

[matteovid]

Ciao Gila

non dico che non hai capito nulla. Se hai capito questo ti chiedo scusa, ma ti spronerei a non incaponirti su ** e vai di funzioni... almeno dai un idea di avere sotto controllo l'argomento...

certo che vedo i tuoi esempi e infatti cerco capirli, ma siccome sei sempre dentro il main e dici che dal main devi avere ** e adesso perchè hai fatto le liste coi nodi dummy o altro ritieni che sia sempre così... per me è sbagliato, ripeto per me....

Attenzione: devi solo applicarti un pochino di più sugli esempi che scrivi:

almeno per me è così
forse per altri è diverso, ma ripeto è una mia impressione che non usi almeno degli esempi più costruttivi...

É come se hai una macchina e la sfrutti solo a motore spento e in folle, se vai in discesa per forza di inerzia tutto bene, poi al piano e alla prima asperità sei fermo

Matteo

[matteovid]

Sinceramente in quella discussione, nessuno aveva detto che le funzioni, gli argomenti e i puntatori erano sbagliati...mi giunge nuova.

ma chi ha detto sbagliato... ripeto non mi sono spiegato...

sinceramente uno che arriva alle liste e puntatori a funzioni dovrebbe almeno avere chiaro il concetto di funzione e puntatori normali, cosa che tu a mia impressione, ripeto a mia impressione non hai, ma non dico che non capisci, dico che devi applicarti nei tuoi esempi, che fai a casa, nel tempo libero o quando lo ritieni neccesario....

non dare la colpa al tuo manuale, se lo hai scelto lo devi seguire, passo a passo, col tuo ritmo....

comunque vedendo che non ti sia d'aiuto mi ritengo non pronto per aiutarti, quindi lascio ad altri il pevilegio di aiutarti...

comunque di tutto in questo thread non hai risposto a @vbxtreme al suo esercizio...

Matteo

[gila75]

Ho spiegato più volte l'inghippo del **.
E ho ribadito di aver preso fischi per fiaschi...ma a quanto pare non riesco a farmi capire.
Ho anche ripetuto più volte che ho postato la versione corretta del passaggio di un puntatore a funzione, ma anche qui...non riesco a farmi capire.

comunque di tutto in questo thread non hai risposto a @vbxtreme al suo esercizio...

Bhè...ci stavo lavorando, non è così semplice da autodidatta.
I puntatori, non li saprò così bene come voi, non discuto, ma penso di aver capito qualcosa...ma a quanto pare dopo aver detto la
castroneria del ** mi sono screditato e non ho capito nulla . Spero per me che abbiate torto...

Va bhè...ormai il 3d è un pò naufragato, lasciamo perdere, non so se è più il caso di proseguire.
Il manuale, l'ho scelto io è vero , ma senza nessun criterio, non sapevo se fosse buono o no.
Ma ti grantisco che liquida l'argomento in due esempi, anche poco chiari.
Lontano anni luce dall'esercizio di vbextreme.

[matteovid]

Ho spiegato più volte l'inghippo del **.
E ho ribadito di aver preso fischi per fiaschi...ma a quanto pare non riesco a farmi capire.
Ho anche ripetuto più volte che ho postato la versione corretta del passaggio di un puntatore a funzione, ma anche qui...non riesco a farmi capire.

comunque di tutto in questo thread non hai risposto a @vbxtreme al suo esercizio...

Bhè...ci stavo lavorando, non è così semplice da autodidatta.
I puntatori, non li saprò così bene come voi, non discuto, ma penso di aver capito qualcosa...ma a quanto pare dopo aver detto la
castroneria del ** mi sono screditato e non ho capito nulla . Spero per me che abbiate torto...

Va bhè...ormai il 3d è un pò naufragato, lasciamo perdere, non so se è più il caso di proseguire.
Il manuale, l'ho scelto io è vero , ma senza nessun criterio, non sapevo se fosse buono o no.
Ma ti grantisco che liquida l'argomento in due esempi, anche poco chiari.
Lontano anni luce dall'esercizio di vbextreme.

OK continui sul **
allora resta fermo qui sul **, e non andare più avanti...

che abbia torto può essere, ma sai o io sono imbecille o le mie applicazioni funzionano per sentito dire, e pensa me le hanno anche pagate, ma continuano a funzionare, anche controllate da esperti... visto che curo più la parte elettronica...

che lo abbia fatto naufragare non so, ma il thread lo hai aperto tu, con una domanda specifica.... poi che continui a specificare il ** come se avessimo tutti torto, hai ragione tu, ripeto hai ragione tu

ti incaponisci su concetti del **, ma poi non prosegui, te la sei legata al dito, allora dimostra il tuo punto di vista con un esempio concreto, che si possa capire dove ho sbagliato... ma concreto non con due instruzioni in croce...

non è questione di capire i puntatori nel tuo modo o nel mio o di altri, i puntatori sono dichiarati/inventati da persone che ne sanno infinitamente molto più di me e te , basta leggere cosa scrivano loro sui puntatori... per capirli...
è come fare la doccia, non ci vai con i panni adosso, ci vai spogliato, per una semplicissima ragione, così come i puntatori...
non esiste il ma il bho del manuale... ci sono e si usano per quello che sono inventati... nè più ne meno...
come le funzioni e altro sul C... caratteristica del C sono le funzioni e i puntatori, questo è quello che....

Matteo

[gila75]

che abbia torto può essere, ma sai o io sono imbecille o le mie applicazioni funzionano per sentito dire, e pensa me le hanno anche pagate, ma continuano a funzionare, anche controllate da esperti... visto che curo più la parte elettronica...

che lo abbia fatto naufragare non so, ma il thread lo hai aperto tu, con una domanda specifica.... poi che continui a specificare il ** come se avessimo tutti torto, hai ragione tu, ripeto hai ragione tu

ti incaponisci su concetti del **, ma poi non prosegui, te la sei legata al dito, allora dimostra il tuo punto di vista con un esempio concreto, che si possa capire dove ho sbagliato... ma concreto non con due instruzioni in croce...

ok...ti stai scaldando un po'...ti hanno pagato le applicazioni, sei bravo ? ok buon per te.
Io non mi sono legato al dito nulla, e non devo dimostrare nulla.
Non capisco questo sbotto, non mi sono incapponito a dire si ho ragione.
Comunque Matteo...grazie lo stesso.

[matteovid]

prego MAESTRO

sapientone e provocatore, tipico del sotutto e tu no, jeje, tipico....

io sto imparando, vado a scuola, e lavoro...

"bravo" lo tieni per te, provocatore, CAPITO....

Spero per me che abbiate torto...

infatti ....


Matteo

[vbextreme]

penso che in un forum ci debbano essere solo critiche costruttive e non inutili polemiche.Ricordando anche che non é obbligatorio intervenire ad una discussione.

Il livello di apprendimento é diverso per ognuno di noi.
L'unica critica forse va fatta al libro e come già suggerito,io proseguirei con lo studio e magari valuterei l'acquisto di un nuovo manuale.
Se non si ha credito allora si potrà valutare il download di qualche libro in formato pdf,ce ne sono una decina, anche in questo stesso forum c`é una sezione dedicata proprio ai suddetti manuali.

L'unica cosa che secondo mé permette un pò di gongolarsi é l'essere di aiuto a qualcuno e non di aver raccattato un paio di spiccioli.

[gila75]

prego MAESTRO

sapientone e provocatore, tipico del sotutto e tu no, jeje, tipico....

io sto imparando, vado a scuola, e lavoro...

"bravo" lo tieni per te, provocatore, CAPITO....

Spero per me che abbiate torto...

infatti ....


Matteo

No è quello il punto Matteo, non sono un provocatore e so tutto io, puoi leggere tutti i miei 3d.
Sono qui per imparare, ma mi sembrava ti stessi scaldando un po'. E io non ho dato dell'imbecille a nessuno.
Ho già letto i tuoi interventi e so che sei preparato.
Libero di non partecipare più ai mie 3d, ma vorrei facessimo pace...virtulamente
Il fatto che ho scritto solo 3 righe e nel main, è perchè sto facendo prove tutto qui.
Bravo non era ironico comunque, da quello che dici sei davvero bravo e io non sono un maestro.
Tutto qui.