[C] Organizzazione file .h e .c per oggetto "pila"

[duonovembre]

xfetto, guardo annozero e ci provo!
grazie

[duonovembre]

rieccomi sono stato assente per un po' ma nn e' tutta colpa mia (so ke vi sono mancato)

cmq sto provando ad utilizzare la malloc come suggerito da oregon per l'array ma non riesco proprio a figurarmi la struttura del programma

es: domanda 1 (risolto questo provo a fare il resto e passero' alle altre domande thx):

io alloco un tot di memoria per il mio array e la passo ad un puntatore

int * p = (int *)malloc (sizeof(int)*100);

questo dovrebbe allocare memoria per un array di 100 interi o per un array di 100 puntatori?

[shodan]

Allochi memoria per 100 interi.
Un modo veloce di capirlo è vedere che nella malloc c'è: sizeof(int)*100
Se fossero stati 100 puntatori avresti dovuto scrivere: sizeof(int*)*100 e tutto il resto di conseguenza.

[duonovembre]

thx, infatti provando sono riuscito a farlo funzionare

utilizzando pero' la push ho sempre l'errore che avevo prima, risultati senza senso, quando invece se inserisco i dati direttamente dal main funziona tutto come dovrebbe

non sono ancora entrato bene nel modo di ragionare da C e non riesco a distaccarmi dalle regole java.

dovrei utilizzare una pila statica oppure un "oggetto" pila e passarne il puntatore alla funzione push?

[shodan]

Apri un nuovo thread e posta il codice.

[duonovembre]

te lo scrivo qui per non far arrabbiare i mod

questo e' lo stack

#include "stackdef.h"

int * stack(){
    DIM = 100;
    int *p = (int *) malloc(sizeof(int)*DIM);
    size = 0;
    return p;
    
    
    
    
    }

in stackdef ho messo solo le definizioni di queste variabili globali

int DIM;
int size;

questo invece e' lo stackop

#include "stackdef.h"

void push(int a, int*p){
   
    if (size==0){  p[size] = a;size++;}
     
     else {
           int i = size -1;
     p[size] = p[i];
         
          for (i; i>0;i--){
          p[i] = p[i-1];
          }
          p[0] = a;
          size++;
          
          }
     
     
     }
//ritorna il primo elemento della pila
int pop(int*p){
    if (size ==0)return 0;
    int a = p[0];
    int i =0;
    size--;
    for (i;i<size;i++){
        p[i] = p[i+1];
        }
    return a;
    }
int peek(int*p){
    if (!size) return 0;
    else return p[0];
    }
    
int Size(){
    return size;}
    
    int Empty(){
        if (size) return 1;
        else return 0;}

(per ora ho omesso i controlli di dimensione ecc.)
il programma funziona ma credo che sia inefficiente da un punto di vista logico
mi spiego:

io imposto le variabili DIM e e size come globali, quindi queste sono leggibili da chiunque ma non sono legate alla singola pila giusto?

cioe' se mentre io sto lavorando con una pila ne creo un altra automaticamente perdo l'informazione della size sulla prima giusto?
dovrei o rendere il tutto globale oppure creare uno stack nel quale ad ogni pila corrisponde una DIM ed una size giusto?

se decido di seguire la seconda strada come dovrei definire la malloc?
e dove dovrei definire la definizione della pila? in un .h o nel file stack.c?

thx

[shodan]

la dichiarazione va nel .h
la definizione nel .c

Se non vuoi ricorrere a variabili globali (quasi sempre inutili IMHO) che creano solamente confusione, usa le struct ( se puoi )

nel file.h

struct Stack {
   int *data;
   int  size;
};

void initStack(struct Stack *st, int len);

nel file.c

void initStack(struct Stack *st, int len) {
   st->size = len;
   st->data = (int*) malloc(st->size*sizeof(int));
}

in questo modo raggruppi i dati.

struct Stack stack1;
struct Stack stack2;

initStack(&stack1, 100);
initStack(&stack2, 300);

ovviamente poi dovrai invocare la free sul campo data quando non ti serviranno più. Questo è il modo più pratico per risolvere il problema.
Ometto controlli vari per brevità.

[duonovembre]

perfetto, credo di aver capito!

ti ringrazio!

[duonovembre]

AGGIORNAMENTO:

il mio professore ha posto una soluzione logica al problema (ma secondo me errata, ho provato a tradurla in codice e il DEV sembra darmi ragione) voi che ne pensate?

file Stack.h
-----------------
#define size 10
Struct Stack{
int a[size];
int p:}
------------------


file Stack.c
------------------
#include "Stack.h"
Struct Stack S;
-------------------


StackOp.h
------------------
(vi sono i prototipi delle funzioni
e' il file che verra' incluso per utilizzare
lo stack)
-------------------


StackOp.c
-------------------
#include "Stack.h"
#include "StackOp.h"
-------------------

questo e' diciamo la struttura, ma secondo me e' errata perke' includendo in due file Stack.h che ha al suo interno il #define size 10, effettua una doppia dichiarazione (e' una macro ok ma il compilatore me lo segna come doppia definizione, come potrei risolvere?)

e a parte questo il codice di StackOp non vede S dichiarata in Stack.c, neanche se dichiarata come extern. qual'e' secondo voi la soluzione ottimale mantenendo pero' di forma questo stile?


sto procedendo per piccoli cambiamenti, ho eliminato la variabile size (pressoche' inutile conoscendo a priori la dimensione si puo' modificare direttamente il codice)

[Xaratroom]

Devi usare la direttiva di precompilazione ifndef su una macro definita dentro il blocco selettivo ....
Oppure #pragma once in testa ai .h