[C] Funzione che dovrebbe restituire un vettore

[Suwako27]

Ciao a tutti, ho dei dubbi riguardo le funzioni che dovrebbero ritornare ""array"":

Codice:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void trovaMax(int* a, int n)
 {
    int cont = 0;

    if(*a > *(a + 1)) {printf("%d|", *a); cont++;}
    int* b = a + 10;
    a++;
    while(a < b)
    {
       if((*a > *(a - 1))&&(*a > *(a + 1)))
       {
         printf("%d|", *a); cont++;
       }
       a++;
    }
    if(*b > *(b - 1)) {printf("%d|", *b); cont++;}
    printf("\n\n%d", cont);
}
int main()
{
   srand(time(0));
   int n = 11;
   int* a = malloc(sizeof(int)*n);
   for(size_t i = 0; i < n; i++)
   {
      a[i] = rand()% 300;
      printf("%d|", a[i]);
   }
   puts("\n");
   trovaMax(a, n);
}

Il testo di questo esercizio chiede di trovare in un array i "max parziali", cioè quei termini che sono più grandi di quelli adiacenti. Tuttavia è richiesto che il prototipo della funzione sia del tipo: int * TrovaMaxParziale(int * a,int N); cioè si dovrebbero inserire tutti i max parziali all'interno di questo array. E' possibile quindi fare questa modifica senza complicare inutilmente il codice?

[DeltaEpsilon]

Innanzitutto, ti consiglio di dare un nome simbolico e utile alle variabili... sia per il "te" del futuro, sia per noi del presente, che dobbiamo leggere il tuo codice.

Non capisco perchè utilizzi il parametro della funzione trovaMax come un array ma ti rifiuti di usare il subscript operator: a[1] = *(a+1)

Inoltre, nel main stai allocando memoria dinamicamente, senza mai liberarla... molto male!

Tornando al tuo quesito, se l'esercizio chiede di ritornare un array non vedo il problema: lo allochi (dinamicamente) nella funzione, lo riempi e lo ritorni... ricordando però di liberarlo dalla memoria quando hai finito!

[Suwako27]

È inutile parlare di efficienza, memoria da liberare etc. Dato che è solo un esercizio fine a se stesso; il problema è solo capire l'algoritmo che c'è dietro quello che viene richiesto: In che modo e quando si dovrebbe allocare la memoria dell'array? Prima della chiamata della funzione trovaMax non è chiaro quanti siano gli elementi da inserire nell'array; è quello il mio problema.

[Super Squirrel]

Prima di parlare dell'algoritmo ti faccio una domanda: in che modo una funzione del tipo

Codice:

int* TrovaMaxParziale(int *a, int N);

potrebbe darti informazioni sulla dimensione "utile" dell'array ritornato?

[DeltaEpsilon]

È inutile parlare di efficienza, memoria da liberare etc. Dato che è solo un esercizio fine a se stesso; il problema è solo capire l'algoritmo che c'è dietro quello che viene richiesto:

Io intanto te l'ho detto. Rimanere mediocre o no, è una tua scelta.

In che modo e quando si dovrebbe allocare la memoria dell'array?

Nello stesso modo con cui hai allocato gli altri array. E, come ti ho già detto, nella funzione trovaMax che poi lo restituirà... oppure un parametro di output, ma dubito che l'esercizio voglia quest'ultima strada, dal momento che ti chiede di cambiare proprio il tipo di ritorno della funzione.

Prima della chiamata della funzione trovaMax non è chiaro quanti siano gli elementi da inserire nell'array; è quello il mio problema.

Ed è lo stesso problema che l'allocazione dinamica risolve.

Nel peggiore dei casi, dovrai prima contare quanti elementi ti servono e poi allocare l'array.

Ma, se ho capito bene l'esercizio, qui è banale dedurre la grandezza finale del tuo array con i dati che già hai a disposizione.

[Suwako27]

io intanto te l'ho detto. Rimanere mediocre o no, è una tua scelta

Se ti dico così è perché so cosa andrebbe fatto in questo caso, ma dato che non è il focus principale, quello che hai detto lascia il tempo che trova.

Nel peggiore dei casi, dovrai prima contare quanti elementi ti servono e poi allocare l'array.

Ma, se ho capito bene l'esercizio, qui è banale dedurre la grandezza finale del tuo array con i dati che già hai a disposizione.

È proprio questo il punto; Anche se contassi quanti elementi dovrei inserire nell'array, dovrei effettuare nuovamente la ricerca per l'inserimento in un secondo momento, ed è quello che volevo evitare.

[DeltaEpsilon]

È proprio questo il punto; Anche se contassi quanti elementi dovrei inserire nell'array, dovrei effettuare nuovamente la ricerca per l'inserimento in un secondo momento, ed è quello che volevo evitare.

Non c'è bisogno di contarli, è noto a priori (conoscendo N)

[Suwako27]

L'unica cosa che so è il numero massimo ma non quello esatto

[apatriarca]

In linea di massima esistono due metodi per "restituire" un array da una funzione:

1. Restituire un puntatore. La memoria è allocata all'interno della funzione ed è quasi sempre rilasciata dal codice che fa uso della funzione. Il codice avrà una forma come la seguente:

Codice:

int *funzione(..)
{
    int * array = malloc(..);
    // ...
    return array;
}

// codice che fa uso della funzione
int * array = funzione(...);
// ... uso array ...
free(array);


2. Usare un argomento della funzione per restituire l'array. Di solito questo array è allocato e deallocato al di fuori della funzione, ma può anche essere allocato all'interno della funzione. Il codice è qualcosa come il seguente:

Codice:

void funzione(.., int * array_out)
{
    // ... uso array_out ...
}

// codice che fa uso della funzione
int * array = malloc(...);
// ...
funzione(..., array);
// ...
free(array);


Un'ulteriore problematica quando si ha a che fare con array è quella di sapere il numero di elementi inserito. In questo caso abbiamo le seguenti soluzioni:

1. Non fare nulla (nel caso in cui sia già conosciuta la dimensione per altre ragioni).
2. Usare un valore come terminatore dell'array (usanto spesso nelle stringhe).
3. Se l'array è numerico, puoi usare il primo elemento come dimensione dell'array.
4. Puoi usare un argomento della funzione per questo scopo. Avrai quindi un argomento, qualcosa come int *outN, che dovrai riempire con il valore richiesto.
5. Nel caso tu stia usando la soluzione 2 sopra, puoi usare il valore di ritorno della funzione per restituirne la dimensione.
6. Puoi restituire una struttura invece che un puntatore nella soluzione 1 sopra.

[Super Squirrel]

Non c'è bisogno di contarli, è noto a priori (conoscendo N)

Non sono sicuro di aver capito quello che intendi, ma il numero "utile" di elementi (chiamiamolo $M$) del secondo array può variare tra $0$ e $[(N+1)/2]$ (dove le parentesi quadre stanno ad indicare la divisione intera). Quindi, nonostante dipenda da $N$, non è comunque possibile definire $M$ senza aver prima valutato l'array di partenza.

@Suwako
Noto che hai ignorato la mia precedente domanda

Prima di parlare dell'algoritmo ti faccio una domanda: in che modo una funzione del tipo

Codice:

int* TrovaMaxParziale(int *a, int N);

potrebbe darti informazioni sulla dimensione "utile" dell'array ritornato?

in ogni caso, rifacendomi al post di @apatriarca, credo che con quel prototipo l'unica strada percorribile sia la numero 3).