[C] Esercizio Vettore -principiante

[amicoalbi]

Salve ragazzi ho bisogno di una mano con un programmino. Vi riporto la traccia:

Acquisire da tastiera elementi non nulli che compongono il vettore V (il valore nullo blocca l'acquisizione e non il programma e non appartiene al vettore acquisito). Ricercare, in un unico ciclo, la media dei soli valori pari (non di posto pari) presenti nel vettore.

#include "stdio.h"

void input_vett (int x,int V[])
{
    int i;
    do
    {
        printf("inserire dimensione del vettore V\nDimensione Vettore =");
        scanf("%d",&x);
    }
    while (x<2);
    for (i=0;i<x;i++)
    {
        printf("V[%d]=",i);
        scanf("%d",&V[i]);
    }
}

void media_numeri_pari (int x, int V[])
        {
            int i,n=0,c=0;
        for(i=0;i<x-1;i++)
        if (V[i]%2==0);
        {
            n=V[i]+n;
            c++;
        }
    //media aritmetica//
    float m; m=(n/c);
    printf("La media dei numeri pari inseriti è %f",m);
    }
void main()
{
    int x,V;float m;
    void input_vett(int x, int V[]);
    void media_numeri_pari(int x, int V[]);
}

Il programma non funge e credo che i problemi siano nel passaggio delle variabili alle procedure del main ma purtroppo non ne sono venuto a capo.

PS idee su come bloccare l'acquisizione dei valori all'immissione di un valore nullo?

Vi ringrazio in anticipo

[amicoalbi]

Originariamente inviato da Antonio23

aprire un libro di C e studiare il concetto di funzione, cosa sono i parametri attuali e i parametri formali, e come avviene il passaggio dei parametri.

Ahia è davvero così grave?
Ho cercato di scrivere qualcosa basandomi sugli appunti presi in aula.

[sottovento]

Originariamente inviato da amicoalbi

Ahia è davvero così grave?
Ho cercato di scrivere qualcosa basandomi sugli appunti presi in aula.

No, non credo che sia cosi' grave, anzi mi sembra che abbia lavorato bene. Sei sulla buona strada.
Alcuni dettagli:

void input_vett (int x,int V[])

In questo modo, il valore di x puo' essere solo letto da input_vett(): le modifiche che fai al suo interno, verranno perse in uscita da questa funzione.
Dovrai quindi cambiare questo "prototipo" di funzione e specificare che il valore x sara' modificato dalla funzione. Non so se hai bisogno che te lo scriva o se vuoi far da solo (per ora non lo scrivo, fammi sapere se hai bisogno che invece lo faccia)

    for (i=0;i<x;i++)
    {
        printf("V[%d]=",i);
        scanf("%d",&V[i]);
    }

E' corretto e funziona, ma ci sono due problemi:
1 - l'utente potrebbe continuare ad inserire fino a superare la dimensione del vettore;
2 - la traccia, se ho capito bene, diceva che l'acquisizione termina quando viene inserito uno zero (il quale non deve far parte della sequenza) e non c'e' traccia di questa cosa.
Il mio suggerimento e' quello di modificare questo ciclo, magari utilizzando un ciclo while, in modo da rispettare la condizione di uscita all'introduzione di uno zero ed in modo che non sia possibile inserire elementi una volta che il vettore e' riempito correttamente;

void media_numeri_pari (int x, int V[])
{
    int i,n=0,c=0;
    for(i=0;i<x-1;i++)
        if (V[i]%2==0);
    {
        n=V[i]+n;
        c++;
    }
    //media aritmetica//
    float m; m=(n/c);
    printf("La media dei numeri pari inseriti è %f",m);
}

Va benissimo, a parte quell' i < x-1: non ti piace l'ultimo elemento inserito?
(devi arrivare fino a x, cioe' i < x)

void main()
{
    int x,V;float m;
    void input_vett(int x, int V[]);
    void media_numeri_pari(int x, int V[]);
}

Non si compila, vero?
Hai dichiarato V come un intero, non come un vettore di interi. Lo sai come si fa?
Una volta sistemate le dichiarazioni, devi sistemare le chiamate alle funzioni che hai definito. Ti ricordi come si chiamano? La chiamata di una funzione e' stata disegnata in modo che risulti "naturale", come se fosse un qualsiasi altro comando del linguaggio, quindi non hai bisogno di passare il tipo delle variabili e specificare il tipo del valore di ritorno (i.e. void).

Spero di esserti stato utile

[bancodeipugni]

poi l'esame lo passi quest'altr'anno

cmq la dichiarazione di dimensioni va fatta sulla main: le funzioni per un programmino cosi' puoi anche evitarle visto che le metti in fila una dopo l'altra

per dimensionare l'array ci vorrebbe la malloc() con parametro gli inserimenti moltiplicati per sizeof
tuttavia se già troppo avanti puoi limitarti per adesso a fare un array di massima a 1000 elementi

[amicoalbi]

Prima di tutto grazie a tutti.

Mi metto a lavoro manuale alla mano. Posterò i risultati più tardi

[amicoalbi]

Mi sono dedicato allo studio in questo tempo.
Non mi è però ben chiaro come passare per indirizzo la variabile m. In questo caso rimane nel blocco dopo l'if e non ritorna niente nel main?
Questo codice viene compilato ma l'eseguibile si blocca appena dopo l'inserimento del primo elemento del vettore.

PS sono "obbligato" ad usare le funzioni nonostante il programma sia oggettivamente semplice perché nell'esame il prof vuole vedere i passaggi, le chiamate ecc...

Grazie a chi risponderà

#include "stdio.h"
#define MAX 100

void input_vett (int V[])
{
    int i;
    for (i=0;i<MAX;i++)
    do
        {
        printf("Inserire elementi vettore\nV[%d]=",i);
        scanf("%d",&V[i]);
        }
        while (V[i]!=0);
}

float media_numeri_pari (int V[])
        {
        int i,n=0,c=0;float m;
        for(i=0;i<MAX;i++)
        if (V[i]%2==0);
        {
            n+=V[i];
            c++;
            m=(n/c);
        }
        return m;
    }

main ()
{
    int V[MAX]; float p;
    input_vett(V[MAX]);
    p=media_numeri_pari(V[MAX]);
    printf("La media dei numeri pari è %f,p");
}

[bancodeipugni]

si ma V nella main è sciolto... non è assegnato a niente

invece di void input_vett fai int* input_vett()
e ritorna il puntatore al vettore interi

quindi nella main fai V=input_vett(V);

[amicoalbi]

Originariamente inviato da bancodeipugni

si ma V nella main è sciolto... non è assegnato a niente

invece di void input_vett fai int* input_vett()
e ritorna il puntatore al vettore interi

quindi nella main fai V=input_vett(V);

#include "stdio.h"
#define MAX 100

int* input_vett (int V[])
{
    int i;
    for (i=0;i<MAX;i++)
    do
        {
        printf("Inserire elementi vettore\nV[%d]=",i);
        scanf("%d",&V[i]);
        }
        while (V[i]!=0);
        return &V;
}

float media_numeri_pari (int V[])
        {
        int i,n=0,c=0;float m;
        for(i=0;i<MAX;i++)
        if (V[i]%2==0);
        {
            n+=V[i];
            c++;
            m=(n/c);
        }
        return m;
    }

main ()
{
    int V[MAX]; float p;
    V=*input_vett(V);
    p=media_numeri_pari(V);
    printf("La media dei numeri pari è %f",p);
}

Così? Sbaglio sicuro perché non compila.
Definendo int* input_vett (int V[]) sto dicendo che input_vett è puntatore al vettore di interi. Devo fare ritornare l'indirizzo del primo elemento del vettore? Come?

alla riga V=*input_vett(V); ho un bel error: incompatible types when assigning to type 'int[100]' from type 'int'|

Scusate l'incompetenza

[amicoalbi]

Originariamente inviato da Antonio23

media_numeri_pari() ha bisogno di ricevere in ingresso un puntatore al primo elemento dell'array, mentre tu gli passi l'elemento numero 100 dell'array stesso e lo stesso vale per input_vett()

Originariamente inviato da Antonio23

cosa vuol dire non e' assegnato a niente? nel main definisce un vettore allocato nello stack MAX int che chiama V e lo vuole passare alla funzione per farlo riempire..

In effetti l'idea è proprio questa, far riempire il vettore. Non ho capito però come definire un puntatore al primo elemento dell'array. Qualcosa del tipo int *V[0]? Mi pare troppo brutto

[amicoalbi]

Originariamente inviato da Antonio23

puoi usare benissimo il programma originale passando semplicemente V invece che V[MAX]

In effetti adesso non crasha al primo elemento
Però non blocca l'acquisizione degli elementi quando inserisco zero. Come mai?

[vendettaaaaa]

Originariamente inviato da amicoalbi

#include "stdio.h"
#define MAX 100

int* input_vett (int V[])
{
    int i;
    for (i=0;i<MAX;i++)
    do
        {
        printf("Inserire elementi vettore\nV[%d]=",i);
        scanf("%d",&V[i]);
        }
        while (V[i]!=0);
        return &V;
}

float media_numeri_pari (int V[])
        {
        int i,n=0,c=0;float m;
        for(i=0;i<MAX;i++)
        if (V[i]%2==0);
        {
            n+=V[i];
            c++;
            m=(n/c);
        }
        return m;
    }

main ()
{
    int V[MAX]; float p;
    V=*input_vett(V);
    p=media_numeri_pari(V);
    printf("La media dei numeri pari è %f",p);
}

Così? Sbaglio sicuro perché non compila.
Definendo int* input_vett (int V[]) sto dicendo che input_vett è puntatore al vettore di interi. Devo fare ritornare l'indirizzo del primo elemento del vettore? Come?

alla riga V=*input_vett(V); ho un bel error: incompatible types when assigning to type 'int[100]' from type 'int'|

Scusate l'incompetenza

Errore madornale: input_vett non è un puntatore ad un vettore di interi, è una funzione che restituisce un puntatore ad interi e prende in argomento un vettore di interi.
Errore davvero grave questo, devi distinguere funzioni da variabili...

[amicoalbi]

Originariamente inviato da vendettaaaaa

Errore madornale: input_vett non è un puntatore ad un vettore di interi, è una funzione che restituisce un puntatore ad interi e prende in argomento un vettore di interi.
Errore davvero grave questo, devi distinguere funzioni da variabili...

Me lo segno. Stavo cercando di interpretare quanto suggeritomi da un altro utente

Originariamente inviato da Antonio23

ti conviene stampare di volta in volta il carattere che hai effettivamente salvato dopo ogni acquisizione dentro V[i], la newline che aggiungi quando premi invio ma non leggi esplicitamente puo' creare problemi.

per definire un puntatore basta semplicemente una cosa di questo tipo:

int * pInt = &V[0];

Allora sì, se stampo i valori effettivamente li prende.
Ho capito anche qual è la logica: acquisisce sempre il valore dell'elemento i-esimo sostituendolo col precedente e termina l'acquisizione dei dati da tastiera per l'elemento i-esimo soltanto se inserisco 0 fino a riempire tutto il vettore.
Cioè all'avvio se continuo a scrivere valori questi diventano ogni volta il valore di V[0] a meno che non inserisca 0. Così passa a V[1] fino a V[MAX].

La traccia richiede invece che l'acquisizione si fermi proprio al primo valore nullo inserito. Ma in quel caso varierebbe anche la dimensione del vettore in base al numero di valori inseriti fino a quel momento. Consigli su come risolvere questo problema? Cerco di farlo da solo

[bancodeipugni]

Originariamente inviato da amicoalbi

[code]

alla riga V=*input_vett(V); ho un bel error: incompatible types when assigning to type 'int[100]' from type 'int'|

Scusate l'incompetenza

V = input....

per dirla in parole poverem assegnando l'asterisco, assegni a un vettore un solo valore
invece devi assegnare a vettore un vettore cioè puntatore a puntatore

[vendettaaaaa]

Originariamente inviato da amicoalbi

Me lo segno. Stavo cercando di interpretare quanto suggeritomi da un altro utente

Scrivere poi
V = *input_vett(V);
significa:
1) Chiamo la funzione input_vett passandogli V come argomento
2) Prendo il suo valore di ritorno (un int*) e lo dereferenzio usando *
3) Assegno l'int (quando dereferenzi un puntatore, ottieni il valore puntato) a V. E qua c'è l'errore: V è di tipo int[] (cioè int*, ma per ora non chiedere perchè), quindi non puoi assegnargli un int.
Ricapitolando, il tuo codice equivale a:

int* valoreDiRitorno = input_vett(V);
int valorePuntatoDalValoreDiRitorno = *valoreDiRitorno; // Passo da int* a int usando *
// Notare che questo equivale a:
int valorePuntatoDalValoreDiRitorno = operator*(valoreDiRitorno);
// Poichè gli operatori sono alla fin fine delle funzioni (unarie, come in questo caso, o binarie, come il +)
V = valorePuntatoDalValoreDiRitorno; // Errore: assegno un int ad un int[]

Ti consiglio di usare, almeno all'inizio quando devi ancora capire come funziona tutto, di scrivere i passaggi uno ad uno, di modo che capisci bene cosa succede e non fai due operazioni nella stessa riga.

[amicoalbi]

Grazie vendettaaaaa e bancodeipugni per il vostro intervento: è davvero più chiaro adesso.
Chiaro tanto che mi sono ingegnato per cercare di soddisfare la richiesta in maniera più precisa (acquisizione si ferma al primo 0 e questo 0 non fa parte del vettore) e ci sono riuscito... purtroppo solo in parte.
Mi spiego

#include "stdio.h"
#define MAX 10

void input_vett (int V[])

    {int i,t;
        for(i=0;i<MAX;i++)
        {
            printf("Inserire elementi del vettore V\n   V[%d]=",i);
            scanf("%d",&t);
            if(t!=0) V[i]=t; else break;
        }

    }

main()
    {   int V[MAX],i;
        input_vett(V);
        for(i=0;i<MAX;i++) printf("V[%d]=%d\n",i,V[i]);
    }

Inserendo anche la funzione media mi vengono fuori valori strani così ho verificato con delle stampe (PS sono già soddisfatto perché ciò che scrivo venga compilato quasi al primo colpo ).

Ciò che voglio è che il vettore abbia dimensione pari al valore della i dell'ultimo elemento inserito. Il codice che ho scritto non risponde evidentemente alla mia volontà perché il programma riempie il vettore fino a i=MAX con dei valori random (?) o mi mostra gli indirizzi di ogni elemento (?). D'altro canto non specificare la dimensione dell'array vettore nel main vuol dire veder comparire un bel errore...

Qualche dritta anche su questo punto?

PS sto imparando più grazie a voi che alle lezioni in aula praticamente
Birra pagata se passate dalle mie parti

[Oceans11]

Originariamente inviato da amicoalbi

Ciò che voglio è che il vettore abbia dimensione pari al valore della i dell'ultimo elemento inserito. Il codice che ho scritto non risponde evidentemente alla mia volontà perché il programma riempie il vettore fino a i=MAX con dei valori random (?) o mi mostra gli indirizzi di ogni elemento (?). D'altro canto non specificare la dimensione dell'array vettore nel main vuol dire veder comparire un bel errore...

qui o usi l'allocazione dinamica della memoria (vedi malloc e affini), oppure dopo aver riempito il primo vettore (grande a sufficienza ma più del necessario) ne copi il contenuto in uno grande il giusto e butti il primo.

[bancodeipugni]

questo perché non sono probabilmente settati a 0
o usi calloc() o memset() e poi interrompi la stampa al primo NULL che incontra

[vendettaaaaa]

Originariamente inviato da amicoalbi

Grazie vendettaaaaa e bancodeipugni per il vostro intervento: è davvero più chiaro adesso.
Chiaro tanto che mi sono ingegnato per cercare di soddisfare la richiesta in maniera più precisa (acquisizione si ferma al primo 0 e questo 0 non fa parte del vettore) e ci sono riuscito... purtroppo solo in parte.
Mi spiego

#include "stdio.h"
#define MAX 10

void input_vett (int V[])

    {int i,t;
        for(i=0;i<MAX;i++)
        {
            printf("Inserire elementi del vettore V\n   V[%d]=",i);
            scanf("%d",&t);
            if(t!=0) V[i]=t; else break;
        }

    }

main()
    {   int V[MAX],i;
        input_vett(V);
        for(i=0;i<MAX;i++) printf("V[%d]=%d\n",i,V[i]);
    }

Inserendo anche la funzione media mi vengono fuori valori strani così ho verificato con delle stampe (PS sono già soddisfatto perché ciò che scrivo venga compilato quasi al primo colpo ).

Ciò che voglio è che il vettore abbia dimensione pari al valore della i dell'ultimo elemento inserito. Il codice che ho scritto non risponde evidentemente alla mia volontà perché il programma riempie il vettore fino a i=MAX con dei valori random (?) o mi mostra gli indirizzi di ogni elemento (?). D'altro canto non specificare la dimensione dell'array vettore nel main vuol dire veder comparire un bel errore...

Qualche dritta anche su questo punto?

PS sto imparando più grazie a voi che alle lezioni in aula praticamente
Birra pagata se passate dalle mie parti

#include "stdio.h"

#define MAX 10

void input_vett(int V[])
{
	int i, t;

	for (i = 0; i < MAX; ++i)
	{
		printf("Inserire elementi del vettore V\n   V[%d] = ", i);
		scanf("%d", &t);

		if (t != 0)
			V[i] = t;
		else
			break;
	}

}

void main()
{
	int V[MAX] = { 0 };
	int i;

	input_vett(V);

	for (i = 0; i < MAX; ++i)
		printf("V[%d] = %d\n", i, V[i]);
}

Come dice bancodeipugni, il valore dei MAX elementi del vettore è casuale e non settato ad uno specifico valore iniziale.
Questo perchè ogni volta che in C e C++ si alloca spazio in memoria per una variabile di tipo built-in, tale variabile viene inizializzata con un valore casuale (o quasi casuale), ma non a 0 come ci si potrebbe aspettare.
Che la variabile sia una o più (un array) il risultato non cambia, quindi se aggiungi la parte che ti ho messo in rosso tutti i MAX valori saranno inizializzati a 0.

Questo però non risponde alla tua domanda: tu vuoi che nella stampa dopo la chiamata ad input_vett vengano visualizzati solo 6 numeri se ne hai inseriti 6.
Di certo la tua frase "voglio che il vettore abbia dimensione pari all'ultimo numero inserito" contrasta col codice scritto finora: tu dimensioni l'array in modo statico (avrà sempre dimensione MAX: gli array built-in hanno dimensione decisa a compile-time, non puoi cambiarla a runtime; cioè fare

int main()
{
    int n;
    // Leggi n da console
    int V[n] = { 0 };
}

non compila: n dev'essere conosciuto in fase di compilazione). Hai allora due opzioni:
- Fai come ti dice Oceans11, e devi cmq usare malloc per allocare a runtime un vettore del giusto numero di elementi
- Il vettore rimane di dimensione MAX ma lo inizializzi (parte in rosso) con un valore "improbabile", tipo -987654321, e in fase di stampa, dopo input_vett, se V[i] == -987654321 (perchè, in lettura, l'utente aveva inserito uno 0 all'iterazione i-esima) interrompi.

[amicoalbi]

Sì infatti mi sono tirato fuori dall'inghippo in una maniera simile.

#include "stdio.h"
#define MAX 10

main()

    {int i,n,t,V[MAX],N=0; float media=0.; //N è contatore//
        for(i=0;i<MAX;i++)
        {
            printf("Inserire elementi del vettore V\n   V[%d]=",i);
            scanf("%d",&t);
            if(t!=0) V[i]=t; else break;
        }

        for(n=0;n<i;n++)
           {
               if((V[n]%2==0) && (V[n]!=0))
               {
                    media+=V[n];
                    N ++;
               }

           }
            printf("La media dei numeri pari inseriti = %f",media/N);
    }

Semplicemente faccio in questo modo che credo sia l'unico alla mia portata.

Grazie a tutti

[vendettaaaaa]

Indentazione orribile cmq
Ma ne cambierai un po' prima di arrivare a quella che più ti aggrada...