Funzione con stringhe in c.

di Anonimizzato26236 il
10 risposte
Ciao a tutti, tra gli esercizi del mio professore ce n'è uno che richiede lo sviluppo di una function c che restituisca in output la parola più piccola contenuta in un testo e la sua dimensione. Ho fatto l'esercizio e funziona avendo implementato anche il main per provarlo ma tuttavia ci sarebbe un modo per fare si che la parola più piccola insieme alla sua dimensione venga restituita in output dalla funzione? Tramite return ad esempio come richiede la traccia, non riesco perchè la stringa sarebbe di tipo char e la dimensione un int. Posto il codice con la mia prova.

/* Sviluppare una function C che, data come parametro di input una
stringa che rappresenta un testo in italiano, determina e
restituisce come parametri di output la parola di lunghezza minima
contenuta nel testo e la sua lunghezza. Nel testo le parole sono separate da un unico spazio. */


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

void word_min ( char testo[], char parola[], int *n_min);

int main()
{
    char testo [30], parola [10];

        int n_min;

            printf("\nInserisci testo: ");

                gets(testo);

                    word_min(testo, parola, &n_min);

                printf("La parola piu' piccola e' %s ed e' lunga %d", parola, n_min);
    return 0;
}

void word_min ( char testo[], char parola[], int *n_min)
{
    char *token; int n;

        token = strtok(testo, " "); //Spezza il testo

            *n_min = strlen(token); //Assegna ad *n_min la lunghezza del token

                strcpy(parola, token); //Copio la stringa token in parola

                    while ( token != NULL)
                    {
                        n = strlen(token); //Assegno ad n la lunghezza del token

                            if ( n < *n_min )
                            {
                                *n_min = n;

                                strcpy(parola, token);
                            }
                            token = strtok(NULL, " ");
                    }

}

10 Risposte

  • Si fa così (poi modificala tu perché scritta così è veramente orribile, ma è giusto per farti capire)
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    struct parola{
    	char * p;
    	int i;
    };
    
    parola * word_min(char testo[], int lunghezza_testo);
    
    int main()
    {
        char testo [30];  
    	parola * risultato;
    
                printf("\nInserisci testo: ");
    
                    gets(testo);
    
                        risultato = word_min(testo, sizeof(testo));
    
                    printf("La parola piu' piccola e' %s ed e' lunga %d", risultato->p, risultato->i);
        return 0;
    }
    
    parola * word_min(char testo[], int lunghezza_testo)
    {
    	parola * ret = (parola *)malloc(sizeof(parola));
        char *token; int n;
    	ret->p = (char *)malloc(sizeof(lunghezza_testo));
    
            token = strtok(testo, " "); //Spezza il testo
    
                ret->i = strlen(token); //Assegna ad *n_min la lunghezza del token
    
                    strcpy(ret->p, token); //Copio la stringa token in parola
    
                        while (token != NULL)
                        {
                            n = strlen(token); //Assegno ad n la lunghezza del token
    
                                if ( n < ret->i )
                                {
                                    ret->i = n;
    
                                    strcpy(ret->p, token);
                                }
                                token = strtok(NULL, " ");
                        }
    
    	return ret;
    }
  • Weierstrass ha scritto:


    Si fa così (poi modificala tu perché scritta così è veramente orribile, ma è giusto per farti capire)
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    struct parola{
    	char * p;
    	int i;
    };
    
    parola * word_min(char testo[], int lunghezza_testo);
    
    int main()
    {
        char testo [30];  
    	parola * risultato;
    
                printf("\nInserisci testo: ");
    
                    gets(testo);
    
                        risultato = word_min(testo, sizeof(testo));
    
                    printf("La parola piu' piccola e' %s ed e' lunga %d", risultato->p, risultato->i);
        return 0;
    }
    
    parola * word_min(char testo[], int lunghezza_testo)
    {
    	parola * ret = (parola *)malloc(sizeof(parola));
        char *token; int n;
    	ret->p = (char *)malloc(sizeof(lunghezza_testo));
    
            token = strtok(testo, " "); //Spezza il testo
    
                ret->i = strlen(token); //Assegna ad *n_min la lunghezza del token
    
                    strcpy(ret->p, token); //Copio la stringa token in parola
    
                        while (token != NULL)
                        {
                            n = strlen(token); //Assegno ad n la lunghezza del token
    
                                if ( n < ret->i )
                                {
                                    ret->i = n;
    
                                    strcpy(ret->p, token);
                                }
                                token = strtok(NULL, " ");
                        }
    
    	return ret;
    }

    Ciao, grazie per la risposta ma questo è programmazione 1, non vi è allocazione dinamica. Un altro modo per farlo c'è??
  • Ma ti viene richiesto di restituire la stringa o lo vuoi fare tu?
  • oregon ha scritto:


    Ma ti viene richiesto di restituire la stringa o lo vuoi fare tu?
    /* Sviluppare una function C che, data come parametro di input una
    stringa che rappresenta un testo in italiano, determina e
    restituisce come parametri di output la parola di lunghezza minima
    contenuta nel testo e la sua lunghezza. Nel testo le parole sono separate da un unico spazio. */


    Questa è la traccia, la trovi anche nel codice che ho postato io.
  • Saittone ha scritto:


    Weierstrass ha scritto:


    Si fa così (poi modificala tu perché scritta così è veramente orribile, ma è giusto per farti capire)
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    struct parola{
    	char * p;
    	int i;
    };
    
    parola * word_min(char testo[], int lunghezza_testo);
    
    int main()
    {
        char testo [30];  
    	parola * risultato;
    
                printf("\nInserisci testo: ");
    
                    gets(testo);
    
                        risultato = word_min(testo, sizeof(testo));
    
                    printf("La parola piu' piccola e' %s ed e' lunga %d", risultato->p, risultato->i);
        return 0;
    }
    
    parola * word_min(char testo[], int lunghezza_testo)
    {
    	parola * ret = (parola *)malloc(sizeof(parola));
        char *token; int n;
    	ret->p = (char *)malloc(sizeof(lunghezza_testo));
    
            token = strtok(testo, " "); //Spezza il testo
    
                ret->i = strlen(token); //Assegna ad *n_min la lunghezza del token
    
                    strcpy(ret->p, token); //Copio la stringa token in parola
    
                        while (token != NULL)
                        {
                            n = strlen(token); //Assegno ad n la lunghezza del token
    
                                if ( n < ret->i )
                                {
                                    ret->i = n;
    
                                    strcpy(ret->p, token);
                                }
                                token = strtok(NULL, " ");
                        }
    
    	return ret;
    }

    Ciao, grazie per la risposta ma questo è programmazione 1, non vi è allocazione dinamica. Un altro modo per farlo c'è??
    Sì: fissare la dimensione massima possibile
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define MAX_DIM 100
    
    struct parola{
    	char p[MAX_DIM];
    	int i;
    };
    
    parola word_min(char testo[]);
    
    int main()
    {
        char testo[MAX_DIM];
    	parola risultato;
    
                printf("\nInserisci testo: ");
    
                    gets(testo);
    
                        risultato = word_min(testo);
    
                    printf("La parola piu' piccola e' %s ed e' lunga %d", risultato.p, risultato.i);
        return 0;
    }
    
    parola word_min(char testo[])
    {
        parola ret = {{0},0};
        char *token; int n;
    
            token = strtok(testo, " "); //Spezza il testo
    
                ret.i = strlen(token); //Assegna ad *n_min la lunghezza del token
    
                    strcpy(ret.p, token); //Copio la stringa token in parola
    
                        while (token != NULL)
                        {
                            n = strlen(token); //Assegno ad n la lunghezza del token
    
                                if ( n < ret.i )
                                {
                                    ret.i = n;
    
                                    strcpy(ret.p, token);
                                }
                                token = strtok(NULL, " ");
                        }
    
    	return ret;
    }
  • Sprechi un po' di spazio passando la stringa di dimensione massima. Non usare la struttura ma passala tra gli argomenti come dice il testo
  • oregon ha scritto:


    Sprechi un po' di spazio passando la stringa di dimensione massima. Non usare la struttura ma passala tra gli argomenti come dice il testo
    La struttura gliela ho messa io perché pensavo volesse tutto nel return value: se come output vanno bene i puntatori nel prototipo è già giusta la sua soluzione di partenza...
  • Weierstrass ha scritto:


    oregon ha scritto:


    Sprechi un po' di spazio passando la stringa di dimensione massima. Non usare la struttura ma passala tra gli argomenti come dice il testo
    La struttura gliela ho messa io perché pensavo volesse tutto nel return value: se come output vanno bene i puntatori nel prototipo è già giusta la sua soluzione di partenza...
    Sì ma dovrà modificare

    parola [10];

    in

    parola [30];
  • Saittone ha scritto:


    e venga restituita in output dalla funzione? Tramite return ad esempio

    come richiede la tracci

    /* Sviluppare una function C che, data come parametro di input una
    stringa che rappresenta un testo in italiano, determina e
    restituisce come parametri di output la parola di lunghezza minima
    contenuta nel testo e la sua lunghezza. Nel testo le parole sono separate da un unico spazio. */
    Secondo me ti stai complicando inutilmente la vita e rischi che il prof ti segni errore!
    La dicitura "parametri di output" per me è chiarissima e non si riferisce affatto al "valore di ritorno" della funzione.
  • Int parola_minima( const char *testo, const char **p_min, unsigned int *l_p_min );

    Il parametro testo è la stringa in ingresso.
    In uscita, il parametro p_min ("parola minima") è un puntatore al carattere iniziale della parola trovata.
    In uscita, il parametro l_p_min ("lunghezza della parola minima") è un puntatore ad un unsigned int destinato a notificare la lunghezza della parola trovata.
    Il valore di ritorno potrebbe riguardare un'eventuale condizione di errore (ad esempio la presenza di puntatori NULL tra i parametri).

    Ovviamente, con una impostazione di questo tipo la parola puntata da p_min potrebbe NON essere una stringa C "zero terminated", ma basterebbe esserne consapevoli ed agire di conseguenza.
Devi accedere o registrarti per scrivere nel forum
10 risposte