Newsgroup: it.comp.lang.c
Titolo: Aiutoooooo

Ciao,
chi mi da una mano per fare il seguente esercizio ? Mi basta un piccolo 
aiuto e poi tento di completarlo da sola. Se qualcuno mi manda l'intero 
codice....ben venga :)
Segue l'esercizio e la traccia dell'algoritmo che DEVO seguire.
Grazie
Rossana
------------------
Esercizio: Un programma che accetta n interi fino all’inserimento dello zero 
e li registra su un array dinamico.
Algoritmo:
Chiedo un intero. Mediante malloc creo un area sufficientemente grande da 
contenere l’intero.
pArray = ( int * ) malloc (sizeof(int);
Copio l’intero in un array…
Chiedo un altro intero. Mediante malloc creo un area sufficientemente grande 
da contenere il vecchio array + 1 elemento.
Copio il vecchio array nel nuovo aggiungendo in fondo l’ultimo
elemento. Per fare ciò definisco un puntatore che punta al primo elemento 
dell’array. Copio il valore puntato dal puntatore nel secondo array. 
Incremento di uno il valore puntato dal puntatore e copio il
valore nel nuovo array. Quando ho copiato l’ultimo elemento dell’array 
vecchio copio nell’array nuovo il numero appena inserito.
Libero il vecchio array e chiedo un nuovo inserimento
Se inserico zero esco.
_________________________________________________________________________
Get Your Private, Free E-mail from MSN Hotmail at 
http://www.hotmail.com
.
-- 
Posted from [147.123.1.111] by way of 
f59.law11.hotmail.com
 [64.4.17.59] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Ecco quello che sono riuscita a "partorire" fino ad ora.....una vera 
schifezza.
Mi da 8 errori a partire da dove dichiaro il puntatore int* p1Array e non 
capisco il perchč.
Il primo segnale di errore localizzato sulla riga di codice
int* p1Array mi dice " error C2143: syntax
error : missing ';' before 'type' ".....non capisco dove manca il; 
.......vorrei tanto capirlo.
Il mio insegnante mi ha detto di seguire questa strada dei malloc, ma parte 
gli errori (orrori) di sintassi, mi chiedo se esista un modo "iterativo" 
perchč, non č molto "economico" allocare, copiare, cancellare tutte le volte 
una array che, allimite, potrebbe riguardare 4000 interi.
In ogni caso prego qualche gentile frequentatore di questo forum di dare un 
occhiata e una ripulita a quello che ho fatto finora basandomi su questo 
schema. Se poi mi direte come andare avanti sarň ancora piů felice :)
Grazie :)
Rossana
// ArrayDinamico del 01 Luglio 2001
#include <stdio.h>
#include <conio.h>
#include <malloc.h>
void stamparray (int* myarray, int lunghezzarray);
void main (void) {
int* pArray;
int numeroInserito1;
printf("\nPrego inserire un intero:\t");
scanf ("%d", &numeroInserito1);
if (numeroInserito1 ==0)
{
printf("\nFine del programma!");
return;
}
// Creo un area sufficientemente grande da contenere l'intero
pArray = ( int* ) malloc (sizeof(numeroInserito1));
if (pArray  == NULL)
{
  printf("\nButta via sto computer!");
  return;
}
pArray[1] = numeroInserito1;
//Secondo numero
int* p1Array;
int numeroInserito2;
printf("\n Prego inserire un altro intero:\t");
scanf ("%d", &numeroInserito2);
if (numeroInserito2 ==0)
{
printf("\nFine del programma!");
return;
}
// Creo un area sufficientemente grande da contenere gli interi
p1Array = ( int* ) malloc (sizeof(numeroInserito1)+(numeroInserito2));
if (p1Array  == NULL)
{
  printf("\nButta via sto computer!");
  return;
}
p1Array[1] = pArray[1];
p1Array[2] = numeroInserito2;
free (pArray);
}
_________________________________________________________________________
Get Your Private, Free E-mail from MSN Hotmail at 
http://www.hotmail.com
.
-- 
Posted from [147.123.1.111] by way of 
f139.law11.hotmail.com
 [64.4.17.139] 



I'm not prejudiced, I hate everyone equally.

 gli errori (orrori) di sintassi, mi chiedo se esista un modo "iterativo"
cerrto che si puň..esistono i cicli no?
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void stamparray (int* myarray, int lunghezzarray)
{
 int i;
 for(i = 0; i < lunghezzarray; i++)
  printf("%d  ", myarray[i]);
}
int main ()
{
 int* pArray = NULL, *temp, n, i = 0;
 while(1)
 {
  /*printf("\nPrego inserire un intero:\t");
  scanf ("%d", &n);*/
  n = rand();
  if(n == 0)
   break;
  temp = malloc(sizeof(int) * i);
  memcpy(temp, pArray, sizeof(int) * i);
  free(pArray);
  pArray = malloc(sizeof(int) * (i + 1));
  memcpy(pArray, temp, sizeof(int) * i);
  pArray[i] = n;
  free(temp);
  i++;
 }
 stamparray(pArray, i);
 printf("\nnumeri di elementi = %d\n", i);
 free(pArray);
 return 0;
}
per funzionare funziona, ma non so se č la soluzione migliore.

             ^^^^^^^^^ NO ...
forse voleva fare sizeof(numeroinsertio1 + numeroinserrto2)
cmq molto più leggibile
sizeof(int) * 2

 leggibile pArray[0] = numeroinserito1;
hai ragione ... ma secondo te non e' meglio che inizi con l'imparare
l'uso dei deferenziatori ?
ciao ...



Segue il codice che realizza le tue (orrende) specifiche.
Spero che i commenti siano abbastanza chiari.
HTH
------------------------------------------------------------------------
---------------------
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int   GetInput(void);
int * AddToArray(int NewItem, int * OldArray, int * size);
void  PrintArray(int * Array, int size);
int main(void) {
   int *Array = NULL; /* Inizializza array vuoto */
   int size   = 0;    /* Numero elementi dell'array */
   int Input = 1; /* variabile che contiene l'intero inserito */
   /* 1 assicura che il ciclo while sia eseguito almeno una volta */
   fprintf(stderr,"Inserisci una serie di interi - (0=fine)\n");
   while ( (Input = GetInput()) != 0)
      Array = AddToArray( Input, Array, &size);
   if (size > 0)
      PrintArray(Array,size);
   if (Array != NULL)   free(Array);
   return EXIT_SUCCESS;
   }
int   GetInput(void) {
   int x;
   return (scanf("%d",&x) == 1) ? (x) : (0);
   }
int * AddToArray(int NewItem, int *OldArray, int *size)  {
   /* Puntatore al 1o elemento del vecchio array */
   int *old1=OldArray;
   /* Puntatore alla posizione successiva all'ultimo
      elemento del vecchio array   */
   int *last=OldArray + (*size);
   int *NewArray = NULL; /* Puntatore al nuovo array */
   int *new = NULL;      /* puntatore ausiliario per la copia */
   ++(*size);   /*incrementa numero elementi */
   NewArray = malloc(sizeof(int)*(*size));
   assert (NewArray != NULL);
   /* Copia il vecchio array nel nuovo */
   new = NewArray;
   /* Copia vecchio -> nuovo array
      Al primo elemento inserito old1==last
      ed il ciclo non viene eseguito
   */
   while (old1 != last) {
      *new = *old1;
      ++old1;
      ++new;
      }
   *new = NewItem;   /* Inserisce nuovo elemento */
   free(OldArray);   /* dealloca il veccio array */
   return NewArray;
   }
void  PrintArray(int * Array, int size) {
   int i;
   /* usando stdout risulta possibile la redirezione su file */
   system("cls"); /* pulisce lo schermo */
   fprintf(stderr,"L'array contiene %d elementi\n",size);
   for (i=0; i < size; ++i)
      fprintf(stdout,"%6d\n",Array[i]);
   }

 Spero che i commenti siano abbastanza chiari.
Io mi sono rifuitato di metterli ;-)
Solo un appunto sul tuo programma (visto che non ho avuto voglia e nemmeno
coraggio di leggerlo) non e' un tantino lungo ?!?
Alex

Propongo questa alternativa.
Ciao:)
#include <stdio.h>
#include <conio.h>
#include <malloc.h>
/* l'iterazione č necessaria e la si puň fare con cicli while o
 do...while */
void main (void) { /*perchč non int main (void) ???? */
 int* oldArray; /*warning C4101:'oldArray':unreferenced local
    variable....perchč? */
 int* newArray;
 int size;
 int number;
 size = 0;
 printf("\nPrego inserire un intero:\t");
 scanf ("%d", &number);
 while (number != 0)  {
/*   alloco un'area sufficiente a contenere un numero di size + 1 interi
     sizeof(int) ovvero 4 bytes per il numero degli elementi contenuti nel
     vettore  oldArray + 1 cioč l'ultimo inserimento! */
   newArray = ( int* ) malloc (sizeof(oldArray) + sizeof(int));
/* oppure
   newArray = ( int* ) malloc (sizeof(int)*(size+1));
// oppure
   newArray = ( int* ) malloc (sizeof(oldArray) + 4); */
// segue test su newArray
/*  copio il contenuto di oldArray cioč di un numero pari a size
interi su newArray e alla fine ci metto l'ultimo numero letto
qui  si puň usare tanto un ciclo for che un while(i<size)
e infine colpo di scena: faccio il free di oldArray per liberare  la
memoria e imposto oldArray = newArray;  in modo che senza ricopiare
oldArray  punta  al vettore coi dati buoni: attenzione non si
deve fare free di newArray  ma al   prossimo giro
solo l'allocazione con malloc! */
   size++;  //   incremento size di 1
   printf("\nPrego inserire un intero:\t");
   scanf ("%d", &number);
 }
 printf("\nFine del programma!");
// qui posso eseguire stampe o altro
 return;
}  // end of program
-- 
Posted from 
dns.onenet.it
 [147.123.225.45] 


 schema. Se poi mi direte come andare avanti sarň ancora piů felice :)
No, mi dispiace ma il tuo codice e' completamente fuori strada. A parte che
le specifiche del tuo prof. sono orribili, la tua implementazione e'
lontanissima dal soddisfarle.
In sostanza non credo sia possibile proseguire con il tuo codice, riprova da
capo...
Alex

 per funzionare funziona, ma non so se è la soluzione migliore.
Io non l'ho provato, quindi do per scontato che funzioni benissimo, ma il
fatto e' che non rispetta le assurde specifiche di Rossana. Rileggitele nel
suo post principale:
Quindi niente :
memcpy(temp, pArray, sizeof(int) * i);
e tantissima altra roba che va fatta diversamente.
In sotanza non sto dicendo che il tuo programma non vada bene (non l'ho
provato), ma sto dicendo che non soddisfa le specifiche fornite da Rossana.
Rileggile attentamente e capirai...
Alex

   newArray = ( int* ) malloc (sizeof(oldArray) + sizeof(int));
A parte il cast, questa istruzione non fa quello che ti aspetti. 
sizeof(oldArray) == sizeof(int*)
Non ottieni la dimensione del vecchio array.
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Let me make your mind, leave yourself behind
Be not afraid