Dubbio sulla struttura dati

di Anonimizzato14574 il
6 risposte
/
Anonimizzato14574
Utente anonimizzato
In realtà non ho ben capito una riga di un codice preso su internet sull'implementazione della struttura lista (il programma funziona correttamente).
quello che non capisco è la scrittura :
void stampaLista(struct elemento *);
void: vuol dire che non ritorna nessun valore
stampalista: è il nome della funzione
struct elemento * :rappresenta l'argomento di tipo struttura che ha definito sopra, ma perchè usa l'asterisco (*)? cosa intende con questa scrittura? quali sono i suoi usi?

altro dubbio è su questa riga:
struct elemento *creaLista();

perchè mette l'asterisco vicino alla funzione creaLista() ?

so che l'asterisco rappresenta un puntatore ma non ho capito in questo caso come lo usa.

posto per completezza l'intero codice:


// crea lista di n elementi
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <malloc.h>

struct elemento{
	int inf;	// valore
	struct elemento *pun; //puntatore elemento successivo
};

struct elemento *creaLista();
void stampaLista(struct elemento *);

int main(){
	struct elemento *lista;
	lista=creaLista();
	stampaLista(lista);
	return 0;
}

struct elemento *creaLista(){
	struct elemento *p,*punt;
	int i,n,K;
	printf("specificare numero elementi ");
	K=scanf("%d",&n);
	if (n==0){
		p=NULL; // Lista vuota
	}else{
		p=(struct elemento *)malloc(sizeof(struct elemento));
		printf("inserisci elemento ");
		K=scanf("%d",&p->inf);
		punt=p;
		for (i=2;i<=n;i++){
			punt->pun=(struct elemento *)malloc(sizeof(struct elemento));
			punt=punt->pun;
			printf("inserisci elemento: ");
			K=scanf("%d",&punt->inf);			
		}
		punt->pun=NULL; //marcatore fine lista
	}
	return (p);	
}

void stampaLista(struct elemento *p){
	printf("lista: ");
	while (p!=NULL){
		printf("%d",p->inf);
		printf("->");
		p=p->pun; // scorre elemento
	}
	printf("NULL \n");
}
grazie in anticipo

6 Risposte

  • /
    Anonimizzato7532
    Utente anonimizzato
    void stampaLista(struct elemento *p)
    La lista è gestita con i puntatori e un puntatore ad una struttura di tipo elemento si raggiunge proprio con la sua notazione *p.

    Essendo p un puntatore si può raggiungere l'elemento puntato da p e poi col p-> posso raggiungere gli elementi delle struttura da lui puntata. Un elemento interessante è p->pun che fa si che p raggiunga il prossimo elemento nella lista. Pensalo come delle scatole legate col filo una coll'altra. p rappresenta la posizione in cui mi trovo adesso (la scatola attuale) e p->pun mi fa andare alla scatola successiva.

    Stesso discorso per 
    
struct elemento *creaLista()
    Questa mi fa tornare un puntatore di tipo elemento che punterà alla prima ed unica scatola creata in questo momento.
  • Super Famoso
    Iscritto da
    nov, 2011
    Messaggi
    21917
    Scatole ...
  • /
    Anonimizzato7532
    Utente anonimizzato
    Thnx, corretto.
  • /
    Anonimizzato14574
    Utente anonimizzato
    Allora intanto grazie per le risposte!
    ho provato a implementare da zero la struttura lista (cercando di cambiare qualcosa) ma mi da errore di segmentazione e non ho capito bene perché.
    

// creazione lista
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
struct SNode{	// struttura che contiene :
	int value;  // informazioni sul nodo
	struct SNode *next; // puntatore al nodo successivo
};

typedef struct SNode TNode; //definito tipo di dato di nome TNode

TNode** creaLista();
TNode** insert(TNode **lista,int elem,TNode **inizio);
void stampa(TNode **lista,TNode **inizio);

int main(){
	TNode **lista,**inizio; // puntatore a puntatore di nodi 
	int scan,n,elem,i;
	lista=creaLista();// puntatore punta a NULL 
	printf("quanti elementi vuoi insierire? ");
	scan=scanf("%d \n",&n); // numeri elementi da inserire
	for (i=0;i<n;i++){
		elem=i;	// per prova prendo elementi = i
		lista=insert(lista,elem,inizio); // inserisco elem in lista
	}
	printf("puntatore è: %d", (*lista)->value);
	stampa(lista,inizio);
	return 0;
}

TNode** creaLista(){
	return NULL;
}

TNode** insert(TNode **lista,int elem,TNode **inizio){
	TNode *newNode;
	newNode=(TNode *)malloc(sizeof(TNode)); //alloca spazio per nodo
	if (lista==NULL){
		newNode->value=elem; // nuovo nodo ha valore elem
		newNode->next=NULL; // imposto puntatore successivo a NULL
		lista=&(newNode); //puntatore lista: punta a nodo successivo
		inizio=&(newNode); // inizio punta al primo elem
		printf("puntatore è: %d", (*lista)->value);
	}else{
		newNode->value=elem; // nuovo nodo ha valore elem
		newNode->next=NULL; // imposto puntatore successivo a NULL
		(*lista)->next=(newNode); //puntatore lista: punta a nodo successivo
		printf("puntatore è dopo f: %d", (*lista)->value);
	}
	return lista;
}

void stampa(TNode **lista,TNode **inizio){
	if (lista==NULL){
		printf("lista vuota \n");
	}else{
		while ((*inizio)->next!=NULL){ // fino a che un nodo non punta a NULL stampo valore dei nodi
			printf("--> %d \n",(*lista)->value);
			inizio=&((*lista)->next);
		}
	}		
}
    ho cercato di commentare anche il codice in modo che per voi fosse più facile capire ciò che intendevo fare.
  • /
    Anonimizzato13826
    Utente anonimizzato
    Sinceramente tutti quei puntatori mi hanno creato un bel po' di confusione

    Per rendere il codice più comprensibile e più semplice ( anche per te ) ti consiglio di usare i puntatori singoli e di "passarli" alle funzioni tramite l'operatore &.
  • /
    Anonimizzato14574
    Utente anonimizzato
    Si in effetti ho fatto cosi e sono riuscito a corregge!
Devi accedere o registrarti per scrivere nel forum
6 risposte