[C/C++] Problemi nell'allocazione di un'array si strutture

[Ntropy]

Salve a tutti, vorrei un aiuto per un piccolo problema.

Ho scritto un programma e vi riporto il codice:

#include <cstdlib>
#include <iostream>
#define SLEN 256
#define ARRAYSIZE 5
#define NUMNODI 3
  
  struct clienti{
         bool flag;
         char filename[SLEN];
         double Xcoords[ARRAYSIZE];
         double Ycoords[ARRAYSIZE];        
  };

  
  
struct clienti* funzione(void);

int main(int argc, char *argv[])
{
  int i,j=0;
  struct clienti *ptr=NULL;

  ptr=funzione();
  
  if(ptr==NULL){
           printf("ptr null!\n");
           exit(-1);
  }
  
  for(j=0;j<NUMNODI;j++){
        
  printf("%s\n",ptr[j].filename);
    
  for( i=0;i<ARRAYSIZE;i++)
       printf("1 - %.2f\n",ptr[j].Xcoords[i]);
        
  for( i=0;i<ARRAYSIZE;i++)
       printf("2 - %.2f\n",ptr[j].Ycoords[i]);   
    
       }

  free(ptr);	
  return 0;
}

struct clienti* funzione(void){
   
   char buffer[SLEN];
   int i,j;
   int randm;
   struct clienti *nodo; 
   
   if (!(nodo=(struct clienti*)malloc(NUMNODI*sizeof(struct clienti)))){
     printf("Memoria non allocabile!\n");
     return NULL;
     }

     for(j=0;j<NUMNODI;j++){
                          
         printf("Inserisci il nome:");
         scanf("%s",buffer); 
         strcpy(nodo[j].filename,buffer);
         
         for( i=0;i<ARRAYSIZE;i++)
             nodo[j].Xcoords[i]=1+rand()%100;
   
         for( i=0;i<ARRAYSIZE;i++)
             nodo[j].Ycoords[i]=1+rand()%100;
                      
   }                
    return nodo;         

}

In pratica il main chiama "funzione" passandogli void e aspetta come valore di ritorno un puntatore alla struttura clienti.
Funzione dal canto suo crea un'array di stutture clienti, fa alcune operazioni e restituisce il puntatore all'array di strutture.

Il programma è compilato e funziona bene ma.........non dovrei usare l'operatore -> per riferirmi ai campi delle singole strutture piuttosto che il punto .
Quando ho provato con -> il compilatore mi sputa fuori che: base operand of `->' has non-pointer type `clienti' .

Qualche suggerimento?

[Ntropy]

nessun aiutino ?

[BrutPitt]

Be' la risposta te l'ha data il compilatore.

L'indicizzazione nodo[j] fa si' che tu ti riferisca al j-iesimo elemento dell'array di strutture... mentre l'operatore "freccia" si usa col puntatore.

Insomma o usi:
(nodo+j)->Xcoords[i]

o usi:
nodo[j].Xcoords[i]

... o ancora:
(*(nodo+j)).Xcoords[i]

Cioe' si usa "." quando si accede direttamente a variabili di tipo struttura... mentre l'operatore "->" si usa quando si accede tramite l'indirizzo, il puntatore alla struttura.

[Ntropy]

Originariamente inviato da BrutPitt

Be' la risposta te l'ha data il compilatore.

L'indicizzazione nodo[j] fa si' che tu ti riferisca al j-iesimo elemento dell'array di strutture... mentre l'operatore "freccia" si usa col puntatore.

Insomma o usi:
(nodo+j)->Xcoords[i]

o usi:
nodo[j].Xcoords[i]

... o ancora:
(*(nodo+j)).Xcoords[i]

Cioe' si usa "." quando si accede direttamente a variabili di tipo struttura... mentre l'operatore "->" si usa quando si accede tramite l'indirizzo, il puntatore alla struttura.

Si credo di aver capito, in pratica accedevo alla variabile senza usare il puntatore ma "toccando" direttamente l'array diciamo così. In pratica per fare la stessa cosa con il main devo usare: (ptr+j)->

grazie di tutto.

[BrutPitt]

Originariamente inviato da Ntropy

Si credo di aver capito, in pratica accedevo alla variabile senza usare il puntatore ma "toccando" direttamente l'array diciamo così. In pratica per fare la stessa cosa con il main devo usare: (ptr+j)->

grazie di tutto.

Si, anche se i metodi ptr[j]. o (ptr+j)-> sono equivalenti. Forse il primo, quello usato da te, gode di maggiore leggibilita' a livello di codice... ma queste sono solo considerazione di forma e assolutamente soggettive.

La potenza dei "puntatori" risiede in altro... ti modifico la tua funzione:

struct clienti* funzione(void){
   
   char buffer[SLEN];
   int i,j;
   int randm;
   struct clienti *nodo,*ptrNodo; //copia di nodo.
   
   if (!(nodo=(struct clienti*)malloc(NUMNODI*sizeof(struct clienti)))){
     printf("Memoria non allocabile!\n");
     return NULL;
     }

    ptrNodo=nodo; //copio l'indirizzo di memoria appena allocato
     for(j=0;j<NUMNODI;j++){
                          
         printf("Inserisci il nome:");
         scanf("%s",buffer); 
         strcpy(ptrNodo->filename,buffer); //accedo tramite puntatore
         
         for( i=0;i<ARRAYSIZE;i++)
             ptrNodo->Xcoords[i]=1+rand()%100; //accedo tramite puntatore
   
         for( i=0;i<ARRAYSIZE;i++)
             ptrNodo->Ycoords[i]=1+rand()%100; //accedo tramite puntatore

        ptrNodo++; //incremento la copia del puntatore
                      
   }                
    return nodo;         

}

A parte la leggibilita', soggettiva, vene ottimizzata anche l'esecuzione:
si evita che ad ogni accesso alla struttura il programma calcoli indirizzo+spiazzamento... (nodo+j) o nodo[j]... incrementando invece direttamente, una sola volta a ciclo, l'indirizzo contenuto in ptrNodo.

Due cosniderazioni:
1) E' necessario fare una copia dell'indirizzo e non agire direttamente su nodo, perche' alla fine del ciclo ptrNodo puntera' all'ultimo elemento, mentre bisogna far "ritornare" l'indirizzo al primo elemento dell'array di strutture.
2) Il codice sarebbe ulteriormente ottimizzabile, ma lasciandolo piu' vicino possibile all'originale si evidenziano meglio le differenze.

[Ntropy]

Originariamente inviato da BrutPitt

Si, anche se i metodi ptr[j]. o (ptr+j)-> sono equivalenti. Forse il primo, quello usato da te, gode di maggiore leggibilita' a livello di codice... ma queste sono solo considerazione di forma e assolutamente soggettive.

La potenza dei "puntatori" risiede in altro... ti modifico la tua funzione:

struct clienti* funzione(void){
   
   char buffer[SLEN];
   int i,j;
   int randm;
   struct clienti *nodo,*ptrNodo; //copia di nodo.
   
   if (!(nodo=(struct clienti*)malloc(NUMNODI*sizeof(struct clienti)))){
     printf("Memoria non allocabile!\n");
     return NULL;
     }

    ptrNodo=nodo; //copio l'indirizzo di memoria appena allocato
     for(j=0;j<NUMNODI;j++){
                          
         printf("Inserisci il nome:");
         scanf("%s",buffer); 
         strcpy(ptrNodo->filename,buffer); //accedo tramite puntatore
         
         for( i=0;i<ARRAYSIZE;i++)
             ptrNodo->Xcoords[i]=1+rand()%100; //accedo tramite puntatore
   
         for( i=0;i<ARRAYSIZE;i++)
             ptrNodo->Ycoords[i]=1+rand()%100; //accedo tramite puntatore

        ptrNodo++; //incremento la copia del puntatore
                      
   }                
    return nodo;         

}

A parte la leggibilita', soggettiva, vene ottimizzata anche l'esecuzione:
si evita che ad ogni accesso alla struttura il programma calcoli indirizzo+spiazzamento... (nodo+j) o nodo[j]... incrementando invece direttamente, una sola volta a ciclo, l'indirizzo contenuto in ptrNodo.

Due cosniderazioni:
1) E' necessario fare una copia dell'indirizzo e non agire direttamente su nodo, perche' alla fine del ciclo ptrNodo puntera' all'ultimo elemento, mentre bisogna far "ritornare" l'indirizzo al primo elemento dell'array di strutture.
2) Il codice sarebbe ulteriormente ottimizzabile, ma lasciandolo piu' vicino possibile all'originale si evidenziano meglio le differenze.

Perfetto è tutto chiarissimo adesso, ti ringrazio vivamente

Se hai qualche ottimizzazione da suggerirmi fallo pure, ogni consiglio è sempre molto gradito.

[BrutPitt]

Originariamente inviato da Ntropy

Se hai qualche ottimizzazione da suggerirmi fallo pure, ogni consiglio è sempre molto gradito.

Nulla di che... eliminavo anche la variabile j che ora funge solo da contatore di ciclo, e non piu' da indice di spiazzamento... e gestivo il ciclo direttamente con un confronto tra indirizzi:

struct clienti* funzione(void){
   
   char buffer[SLEN];
   int i; 
   int randm;
   struct clienti *nodo, *ptrNodo, *ptrEnd; //copia di nodo e indirizzo fineciclo
   
   if (!(nodo=(struct clienti*)malloc(NUMNODI*sizeof(struct clienti)))){
     printf("Memoria non allocabile!\n");
     return NULL;
     }

     ptrEnd = nodo+NUMNODI; //identifico "indirizzo" di fine array...

     //cosi' gestsisco il ciclo con gli indirizzi 

     for(ptrNodo=nodo; ptrNodo<ptrEnd; ptrNodo++){ 
                          
         printf("Inserisci il nome:");
         scanf("%s",buffer); 
         strcpy(ptrNodo->filename,buffer); //accedo tramite puntatore
         
         for( i=0;i<ARRAYSIZE;i++)
             ptrNodo->Xcoords[i]=1+rand()%100; //accedo tramite puntatore
   
         for( i=0;i<ARRAYSIZE;i++)
             ptrNodo->Ycoords[i]=1+rand()%100; //accedo tramite puntatore

   }                

    return nodo;         

}

[Ntropy]

Originariamente inviato da BrutPitt

Nulla di che... eliminavo anche la variabile j che ora funge solo da contatore di ciclo, e non piu' da indice di spiazzamento... e gestivo il ciclo direttamente con un confronto tra indirizzi:

struct clienti* funzione(void){
   
   char buffer[SLEN];
   int i; 
   int randm;
   struct clienti *nodo, *ptrNodo, *ptrEnd; //copia di nodo e indirizzo fineciclo
   
   if (!(nodo=(struct clienti*)malloc(NUMNODI*sizeof(struct clienti)))){
     printf("Memoria non allocabile!\n");
     return NULL;
     }

     ptrEnd = nodo+NUMNODI; //identifico "indirizzo" di fine array...

     //cosi' gestsisco il ciclo con gli indirizzi 

     for(ptrNodo=nodo; ptrNodo<ptrEnd; ptrNodo++){ 
                          
         printf("Inserisci il nome:");
         scanf("%s",buffer); 
         strcpy(ptrNodo->filename,buffer); //accedo tramite puntatore
         
         for( i=0;i<ARRAYSIZE;i++)
             ptrNodo->Xcoords[i]=1+rand()%100; //accedo tramite puntatore
   
         for( i=0;i<ARRAYSIZE;i++)
             ptrNodo->Ycoords[i]=1+rand()%100; //accedo tramite puntatore

   }                

    return nodo;         

}

Eh no ottimo consiglio invece. Ti ringrazio perchè sei stato utilissimo.