Forum Ubuntu-it

Basta semplicemente che lo dichiari void:

typedef void* vector;

non è proprio il massimo e teoricamente è meglio usare una struttura vera e propria

Grazie Vb. In effetti credo anche io.
Ho qualche difficolta sugli adt. L'esempio che ho fatto ok funziona ed è un ADT, ma è troppo modesto e semplice.
Applicare il concetto in modo fluido non mi risulta ancora naturale.
Su un manuale che ho l'argomento lo liquida in 5 pagine, sull'altro invece spiega tecniche avanzate sugli ADT, ma poco sull'implementazione di base....mannaggia!!
Anche se non ci lavoro ed è solo hobby ho l'impressione di buttare via un sacco di ti tempo azz!!!!
Ho guardato anche il tuo framework, che se non fossi così asino io sarebbe una fonte preziosissima, ma davvero è un'altro livello il tuo, e ci sono troppe cose che non
conosco

Guarda che gli adt sono semplicissime strutture, non complicarti la vita, il tutto è un astuto marchingegno per dire "io lo vedo e tu no blablabla".

Ti do il tuo stesso consiglio, vai avanti che poi alla prossima volta che li rileggi li interpreti meglio.

E io che pensavo di aver creato un framework per "neofiti"!!!
L'hai installato?
ti piace il configure?
funziona?
l'hai provato?
considera che la cosa più importante è quella più noiosa e difficile, la documentazione!
Fai degli esperimenti con la easyconsole, prova a chiamare tutte le funzioni e prova a modificarle e a giocarci, alla fine leggi tutto il codice e trai le tue conclusioni. Tale libreria è abbastanza semplice e se trovi errori o possibili soluzioni migliori puoi contribuire.
Qualsiasi domanda sull EF puoi postarla in " progetti comunita->easy framework" qui nel form ubuntu.

L'hai installato?
ti piace il configure?
funziona?
l'hai provato?

No, per ora ho solo dato un occhio per prendere degli spunti.

E io che pensavo di aver creato un framework per "neofiti"!!!

neofiti un po' meno neofiti di me.
Scherzi a parte, è difficile da interpretare per me, io "so" solo il C veramente base. Sul manuale che ho avuto fin ora, spiega solo le operazioni fondamentali, e quando
il codice aumenta di complessità, faccio davvero fatica.
Ti faccio un esempio: sul mio manuale, non viene nemmeno spiegato come passare una struttura ad una funzione, tutte void!!!! Parte dal presupposto che tanto
la struct è globale e quindi non serve passare nulla. E questo è solo un esempio. Puoi immaginare il mio sconforto quando vedo codici più evoluti.
A volte mi viene voglia di abbandonare lo studio.
Mi sembra davvero un gran bel lavoro. Ma non mi voglio dilungare qui, voglio installarla e provarla, (devo capire come si fa), ma ne parliamo nella sezione giusta.

Guarda che gli adt sono semplicissime strutture, non complicarti la vita, il tutto è un astuto marchingegno per dire "io lo vedo e tu no blablabla".

Ti do il tuo stesso consiglio, vai avanti che poi alla prossima volta che li rileggi li interpreti meglio.

Già.

Tornando agli adt: sono giunto alla conclusione che è molto più comodo usare strutture dati piuttosto che l'array dinamico singolo che dicevo.
Riassumendo: il main non può e non deve avere accesso diretto all'implementazione:
main:

Codice: Seleziona tutto

int main(void) 
{   
    Stack s1;
    s1=create();
    stampa(s1);
    return 0;
}

Stack è un tipo astratto e il main non sa neppure cosa sia.
A lui interessa che la variabile s1 (che per ora nemmeno quella sa cosa sia) è il ritorno di una funzione.

Il main quindi fa delle cose, ma non sa cosa.
qui invece:

Codice: Seleziona tutto

#ifndef STRUCT_H
#define STRUCT_H



typedef struct stack_type *Stack;
Stack create(void);
void stampa(Stack s1);

#endif

definisco una struttura incompleta e creo il nuovo tipo puntatore di nome Stack.
Essendo questo il file .h incluso nel main, il main stesso può capire la scrittura

Stack s1;

infatti s1 è una variabile nuova di tipo Stack
come dire

Codice: Seleziona tutto

typedef int prova;
prova x=10;

l'interfaccia .h è quindi opaca (se non ho studiato) male, isola il main dai moduli .c
Il modulo .c poi implementa il tutto.
Quindi, concludendo una volta creato il tipo astratto Stack, io posso modificare la mia struttura a piacimento, inserendo membri float, piuttosto che int,
oppure array ecc...modificando solo il modulo.c
Mi viene dunque da pensare che gli ADT facciano un'uso massiccio di strutture
Non mi è ancora ben chiaro il fatto delle keyword static. In ogni caso il modulo è isolato.
Capisco quando il programma è in più files, ma non stiamo usando un adt, il file.c contiene una funzione che deve stare solo li e allora la dichiaro static.
Ma con adt, faccio fatica.
Devo andare avanti con lo studio evidentemente.
Quello che ho scritto è però corretto?

Si è corretto.
Continua pure nei tuoi studi

Ancora una domanda:

Codice: Seleziona tutto

int main(void) 
{   
    Stack s1;
    s1=create();
    stampa(s1);
    
    return 0;
}

Come potete vedere s1 è un puntatore che riceve il risultato di create che è nel file .c:

Codice: Seleziona tutto

struct stack_type{
int num;
int num_2;
};

Stack create(void)
{
    Stack s=malloc(sizeof(struct stack_type));
    if (s==NULL)
    {
        puts("abort");
        exit(1);
    }
   
    s->num=33;
    s->num_2=22;

   
    return s;


}

ora io mi domando: il main non dovrebbe avere accesso a modificare la struttura nel modulo.c.
Però nel main il puntatore

Codice: Seleziona tutto

 s1=create();

punta all'indirizzo di inizio struttura, quindi come è possibile che non la possa corrompere?
in effetti la scrittura
s1->num non è ammissibile
Da quello che posso intuire s1 è un puntatore solo ad un 'indirizzo e non ha accesso ai membri giusto?

si, ma come hai ben intuito se dichiari la struttura anche nel main sei libero di accedervi col metodo canonico, ma rimane sempre un puntatore e dunque se conosci l'offset delle variabili puoi sempre accedervi anche senza "allegare" la struttura.
Per risolvere questo problema, ad esempio, Windows ha introdotto gli Handle, windows non ritorna un adt, un reale puntatore alla memoria che contiene un oggetto, ma ritorna un numero. Questo numero sarà elaborato prima di accedere alla memoria, questo garantisce una maggiore sicurezza, avviene una cosa simile a questa

Codice: Seleziona tutto

typedef unsigned Handle;

static int obj[100];
static unsigned count = 0;

Handle WinNew()
{
    return count++;
}

void WinSet(Handle h, int val)
{
    obj[h] = val;
}
....

Naturalmente ho semplificato molto ma il concetto è quello.

però è strano, l'indirizzo di una struttura, coincide anche con l'indirizzo del primo membro.
Il c garantisce che all'inizio non ci possono essere buchi, poi tra i membri successivi può accadere.
Ma va bhè, per ora la prendo così: non posso accedere dal main. In fondo un adt è così. Mi sto complicando la vita per nulla.
Solo che quando ho dubbi, mi blocco.

Rieccomi.
Questo dovrebbe essere un esempio un po' diverso dal primo che ho postato.
Il primo definiva un dato incompleto per poi essere completato nel modulo.
Qui invece ho tentato di fare un tipo di dato astratto, sfruttando (per capire ed esercitarmi) la keyword static:
main:

Codice: Seleziona tutto

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

int main(void) 
{   
    
    if (create()==1)
        puts ("operazione sconosciuta al main eseguita con successo\n");
    else
        puts ("fallimento");
    return 0;
}

.h:

Codice: Seleziona tutto

#ifndef STRUCT_H
#define STRUCT_H

int create(void);

#endif

.c:

Codice: Seleziona tutto

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

 int static crea_array()
{
     int i;
     int *s;
    

    s=malloc(10*sizeof(int));

    if (s==NULL)
        return -1;

    for (i=0; i<10; i++)
    {
        s[i]=i+10;
        printf ("%d\n",s[i]);
    }

    
    free(s);
    return 1;
   
}



 int create()
{
   
    return crea_array();  
    
}

Come vedete, è una stupidata, crea un array dinamico di int.
In teoria dovrebbe essere anche questo un adt giusto?
Il main riceve solo il successo o il fallimento di "un qualcosa a lui sconosciuto"
Il tutto, se ho studiato bene viene isolato da:

Codice: Seleziona tutto

int static crea_array()
{
     int i;
     int *s;
    

    s=malloc(10*sizeof(int));

    if (s==NULL)
        return -1;

    for (i=0; i<10; i++)
    {
        s[i]=i+10;
        printf ("%d\n",s[i]);
    }

    
    free(s);
    return 1;
   
}

è corretto?

Aggiungo (intanto aspetto se qualcuno ha consigli su quanto scritto sopra) che se non ho capito male dal mio libro, il primo esempio
dovrebbe essere un adt di prima categoria.
Il secondo esempio, (sempre che sia un adt), non so in che "classe" o categoria ricade.

Nessun consiglio sui due codici? Mi interessa davvero sapere se anche il secondo esempio può essere considerato un adt.
Così poi nel caso metto il risolto.
Grazie lo stesso per le risposte precedenti anche sei il 3d non ha seguito, mi siete stati davvero d'aiuto

l'ultimo codice non ha un gran senso, comunque il principio l'hai capito e ora ti serve farti un po le ossa.
Non impuntarti ma procedi con lo studio che sei sulla strada giusta, considera che certe cose non si riesce a impararle subito,meglio, la teoria generalmente si apprende presto ma poi in pratica è tutta un'altra storia.
Quindi finisci di studiati la "teoria del c" e poi quando inizierai a far pratica imparerai sempre di più, basta solo tanto esercizio.

ok, supponevo che il secondo esempio fosse un po' forzato, anche se in effetti nasconde al main.
Concludo che un esempio di adt sia il primo grazie Vb

Grazie a tutti quelli che mi hanno aiutato, per ora metto il risolto, dubbi futuri avranno altra sede

Forum Ubuntu-it

[Risolto][C] keyword static

Re: [C] keyword static

Re: [C] keyword static

Re: [C] keyword static

Re: [C] keyword static

Re: [C] keyword static

Re: [C] keyword static

Re: [C] keyword static

Re: [C] keyword static

Re: [C] keyword static

Re: [C] keyword static

Re: [C] keyword static

Re: [C] keyword static

Re: [C] keyword static

Re: [C] keyword static

Re: [C] keyword static