[C] Dichiarazione funzione in ANSI C

[Zyzzoy]

Ciao ragazzi, non riesco a capire come farlo.La richiesta è questa:

Si consideri la seguente famiglia di rette descritta dal parametro c e
dalla costante r0 = 2
y = c*x + r0*(sqrt(c*c+1));

che deve essere scritta come una funzione in ANSI C, in modo esteso dichiarando una
variabile locale che `e restituita dal return. Alla funzione devono ovviamente essere passati
tre argomenti: l’ascissa x, il parametro c e la costante r0.

Io non ho mia visto una cosa del genere , 10 errori mi da il programma. Di solito per gli altri esercizi facevo:

double funz (double x);

 poi in fondo a tutto

double funz (double x) {
double y;
y=c[i]*x+r0*(sqrt(c[i]*c[i]+1));
return y;}

Devono essere passati 3 argomenti dice il testo,cercando su internet ho trovato sta forma

double funz (double x,double c, int r0) {

Ma poi non so che proseguire o cosa fare.Non ho ben capito come funziona questo tipo di dichiarazione in C. Qualcuno sa qualcosa? La c deve essere c perchè poi devo metterla nel problema in questo modo per trovare il fascio di rette.

[vict85]

È esattamente come nel caso con un solo parametro. Semplicemente hai 3 parametri invece che uno. Nella chiamata della funzione dovrai inserire 3 valori invece che uno solo.

Separare dichiarazione e inizializzazione di una variabile la ritengo una cattiva prassi. Puoi tra l'altro avere una espressione dopo il return.

[Anacleto13]

double func (double x,double c, int r0) {
    double y = 0;
    y = c*x + r0*(sqrt(c*c+1));
    return y;
}

Fondamentalmente facendo così stai solo ritornano il valore di $y$, se quello è il tuo testo completo non leggo che devi ritornare i valori dei fasci di rette, se è così devi lavorare con gli array.

[Zyzzoy]

Forse l'ansi c chiede questo formato, io non lo so il prof non spiega, il double funz(double y) pensavo andasse bene ovunque, ormai lo facevo in modo automatico, l ho preso da un suo esercizio e funziona in tutti tranne in questo. Dopo un periodo di smarrimento ho trovato come dichiarare le altre variabili tra parentesi, ma come continuare sotto non lo so proprio.

Quando torno a casa poi metto il ciclo array per il calcolo del fascio di rette. In pratica prima con un ciclo for ho inizializzato tutti i c che mi servono, poi con un altro for ho calcolato la coppia x, y con y=funz(x) e funz la funzione che avrei dovuto dichiarare. Mettendo nel ciclo direttamente y=c*x+2*(sqrt(c*c+1)) il problema è risolto, ma lui vuole che dichiaro la funzione e uso x=funz (x) per tirarla in ballo.

Non so se mi son spiegato bene, probabilmente non si capirà nulla di quello che ho scritto. Faccio ingegneria meccanica e quest'esame per me è demoniaco.

[vict85]

"Anacleto13":

double func (double x,double c, int r0) {
    double y = 0;
    y = c*x + r0*(sqrt(c*c+1));
    return y;
}

Fondamentalmente facendo così stai solo ritornano il valore di $y$, se quello è il tuo testo completo non leggo che devi ritornare i valori dei fasci di rette, se è così devi lavorare con gli array.

Dichiarare la variabile a 0 e poi associarne un valore successivamente non ha molto senso. Il C89 (ovvero il datato standard C redatto 30 anni fa che alcuni professori universitari amano senza alcun motivo) non vieta di scrivere qualcosa come

double funzione( double x, double c, int r0 ) {
    double y = c * x + r0 * sqrt( c * c + 1 );
    return y;
}

o addirittura

double funzione( double x, double c, int r0 ) {
    return c * x + r0 * sqrt( c * c + 1 );
}

Vi assicuro inoltre che i compilatori considerano questi due codici come esattamente la stessa cosa e dare un nome a quella espressione non aumenta la leggibilità. Tra l'altro, trovo avesse a quel punto più senso scrivere qualcosa come:

double funzione( double x, double c, int r0 ) {
    double k = c * c + 1;
    double q = r0 * r0 * sqrt( k );
    return c * x + q;
}

Comunque per chiamarla devi semplicemente fare [inline]y[j] = funzione( x[j], c, r0 );[/inline]. Nota che la soluzione originale richiedeva di dichiarare tutto come variabili globali, mentre con la nuova non è più necessario.

[Zyzzoy]

Questo è l'esercizio risolto barando

a=-3.;
b=5.;
c[0]=-2;
incr=0.5;
for (i=1;i<5;i++) {
c=c[i-1]+incr; }



h=(b-a)/6;
for (i=0;i<5;i++) {
for (j=0;j<=5;j++) {
x=a+j*h;
y=c*x+2*(sqrt(1+c*c));
fprintf(fp,"%12.6f %12.6f\n",x,y); }
fprintf(fp,"\n");
}

al posto di y=c*x+2*(sqrt(1+c*c)); devo mettere y=funz(x),e la funz la devo dichiarare fuori dall int main (void). Provo a smanettare un po con le formule da te scritte,la seconda mi sembra la più semplice

[Zyzzoy]

double funz (double x,double c,double r0) {
                      return c * x + r0 * sqrt( c * c + 1 );}
                

Facendo in questo modo mi dice

e.c: In function ‘main’:
e.c:35:25: error: too few arguments to function ‘funz’
                       y=funz (x);
                         ^~~~
e.c:7:8: note: declared here
 double funz (double x,double c,double r0);
        ^~~~
e.c:13:38: warning: variable ‘r0’ set but not used [-Wunused-but-set-variable]
     double h,c[5],a,b,x,y,incr,d,e,t,r0;
                                      ^~

Però senza gli indici come fa a risolvere il problema?

[Anacleto13]

"Zyzzoy":Forse l'ansi c chiede questo formato, io non lo so il prof non spiega, il double funz(double y) pensavo andasse bene ovunque, ormai lo facevo in modo automatico, l ho preso da un suo esercizio e funziona in tutti tranne in questo. Dopo un periodo di smarrimento ho trovato come dichiarare le altre variabili tra parentesi, ma come continuare sotto non lo so proprio..

Giusto per curiosità, che corso è?

"Zyzzoy":
Non so se mi son spiegato bene, probabilmente non si capirà nulla di quello che ho scritto. Faccio ingegneria meccanica e quest'esame per me è demoniaco.

Stessa cosa quando gli informatici fanno qualche corso di meccanica

[Zyzzoy]

fondamenti di informatica T Ingegneria meccanica. Linguaggio C e analisi numerica. Beh dai la meccanica si capiscono bene le basi. Io per imparare i cicli e le cosette base del c ho dovuto sputare sangue e ancora non so nulla praticamente (e non voglio nemmeno sapere nulla, avrei preferisto studiare il turco che informatica, ma purtroppo lo devo dare)

[vict85]

Ecco qualcosa di simile a quel che stai cercando. Nota che, se dovessi risolvere una cosa del genere, non userei questo approccio, perché ti trovi a valutare il seno ogni qual volta vuoi calcolare il valore della funzione.

#include <math.h>
#include <stdio.h>

/**
 * Data la famiglia di rette 
 *     \[\{ f_{c,\ r} = cx + r\sin(c^2 + 1) \colon c, r \in \mathbf{R} \},\]
 * questa funzione calcola il valore della funzione $f_{c,r}$ nel punto $x$.
 */
double funzione( double x, double c, double r );

int main( void )
{
    const double r0 = 2.0;
    const int NUM_RETTE = 5;
    const int NUM_SEGMENTI = 10; 
    double c = 0.1;
    int i = 0;
    for( ; i != NUM_RETTE; ++i )
    {
        double x = 0.0;
        const double d = 1.0 / NUM_SEGMENTI;
        int j = 0;
        for( ; j != NUM_SEGMENTI + 1; ++j )
        {
            x = ( d * j );
            double y = funzione( x, c, r0 );
            printf( "c=%f, r=%f, x=%f, y=%f\n", c, r0, x, y );
        }
        c += 0.1;
    }
}

double funzione( double x, double c, double r )
{
    return x * c + r * sin( c * c + 1 );
}

Avrei verosimilmente fatto qualcosa di questo tipo:

#include <math.h>
#include <stdio.h>

struct Retta {
    double m;
    double q;
};

void calcola_funzione( struct Retta * retta, double c, double r );
double valuta_funzione( struct Retta const * retta, double x );

int main( void )
{
    const double r0 = 2.0;
    const int NUM_RETTE = 5;
    const int NUM_SEGMENTI = 10; 
    double c = 0.1;
    int i = 0;
    for( ; i != NUM_RETTE; ++i )
    {
        struct Retta retta;
        calcola_funzione( &retta, c, r0 );
        const double d = 1.0 / NUM_SEGMENTI;
        double x = 0.0;
        int j = 0;
        for( ; j != NUM_SEGMENTI + 1; ++j )
        {
            x = ( d * j );
            double y = valuta_funzione( &retta, x );
            printf( "c=%f, r=%f, x=%f, y=%f\n", c, r0, x, y );
        }
        c += 0.1;
    }
}

void calcola_funzione( struct Retta * retta, double c, double r )
{
    retta->m = c;
    retta->q = r * sin( c * c + 1 );
}

double valuta_funzione( struct Retta const * retta, double x )
{
    return retta->m * x + retta->q;
}

Comunque secondo me sbagli approccio e sentimento. Finché studierai pensando che "non voglio nemmeno sapere nulla, avrei preferisto studiare il turco che informatica, ma purtroppo lo devo dare" il tuo cervello continuerà a non farti capire alcun concetto di informatica. Ti assicuro che il turco è una lingua molto più complessa (e ambigua) del C.

Il compilatore ti stava comunque dicendo espressamente cosa non andava. Cosa non capivi dei suoi errori?

[Zyzzoy]

double y = funzione( x, c, r0 );

è questo che mi mandava, io mettevo solo funzione (x); , dopo provo a ricalcolarlo. Quindi non si possono tirare in ballo gli indicatori i per svolgere il problema? Io:
-prima inizializzavo tutti i c
-poi con un ciclo esterno e uno interno calcolavo le x e y mettendo nell espressione di y i c (come ho fatto el messaggio prima).


Nel secondo ci capisco poco

struct Retta {
    double m;
    double q;
};

Questa cosa non l'ho mai vista.

Nemmeno questa con le freccie

{
    retta->m = c;
    retta->q = r * sin( c * c + 1 );
}

Provo a farlo come nel primo caso. Oggi ho dato l'esame, e cos ha messo il prof? Quest esercizio nella parte grafica dove già so fare poco o nulla, la funzione non l ho dichiarata e schiaffata direttamente nell int main (void) { , quindi probabilmente il calvario non sarà terminato nemmeno questa volta.


Beh in effetti mi diceva che nella funzione c erano troppi pochi argomenti, mea culpa

[vict85]

Non avevo inizializzato alcun array perché potevo generare i [inline]c[/inline] e gli [inline]x[/inline] durante il ciclo, ma è senz'altro possibile farlo. Per esempio:

#include <math.h>
#include <stdio.h>

/**
 * Data la famiglia di rette 
 *     \[\{ f_{c,\ r} = cx + r\sin(c^2 + 1) \colon c, r \in \mathbf{R} \},\]
 * questa funzione calcola il valore della funzione $f_{c,r}$ nel punto $x$.
 */
double funzione(double x, double c, double r);

int main(void)
{
#define NUM_RETTE (5)
    double c[NUM_RETTE];

#define NUM_SEGMENTI (10)
    double x[NUM_SEGMENTI];

    double y[NUM_RETTE][NUM_SEGMENTI];

    const double r0 = 2.0;

    /* inizializzazione c */
    c[0] = 0.1;
    {
        int i;
        for (i = 1; i < NUM_RETTE; ++i)
        {
            c[i] = c[i - 1] + 0.1;
        }
    }

    /* inizializzazione x */
    x[0] = 0.0;
    {
        int i;
        const double d = 1.0 / NUM_SEGMENTI;
        for (i = 1; i < NUM_SEGMENTI; ++i)
        {
            x[i] = x[i - 1] + d;
        }
    }

    { /* calcolo delle y */
        int i;
        for (i = 0; i < NUM_RETTE; ++i)
        {
            int j;
            for (j = 0; j < NUM_SEGMENTI; ++j)
            {
                y[i][j] = funzione(x[j], c[i], r0);
            }
        }
    }
    { /* stampare a video */
        int i;
        for (i = 0; i < NUM_RETTE; ++i)
        {
            int j;
            for (j = 0; j < NUM_SEGMENTI; ++j)
            {
                printf("c=%f, r=%f, x=%f, y=%f\n", c[i], r0, x[j], y[i][j]);
            }
        }
    }

#undef NUM_RETTE
#undef NUM_SEGMENTI
}

double funzione(double x, double c, double r)
{
    return x * c + r * sin(c * c + 1);
}

Tieni conto che ho scritto il codice in un modo un po' "antiquato", legato al fatto che tu continui ad evidenziare che usi l'ANSI C. Usando l'ultimo standard (che di fatto è anche lui ANSI/ISO[nota]Su gcc, il dialetto C di default è il gnu11 che è una versione modificata dell'ultimo standard.[/nota]) lo avrei potuto scrivere così:

#include <math.h>
#include <stdio.h>

/**
 * Data la famiglia di rette 
 *     \[\{ f_{c,\ r} = cx + r\sin(c^2 + 1) \colon c, r \in \mathbf{R} \},\]
 * questa funzione calcola il valore della funzione $f_{c,r}$ nel punto $x$.
 */
double funzione(double x, double c, double r);

int main(void)
{
    #define NUM_RETTE (5)
    double c[NUM_RETTE] = { [0] = 0.1 };
    for (int i = 1; i < NUM_RETTE; ++i)
    {
        c[i] = c[i - 1] + 0.1;
    }

    #define NUM_SEGMENTI (10)
    double x[NUM_SEGMENTI] = { [0] = 0.0 };
    {
        const double d = 1.0 / NUM_SEGMENTI;      
        for (int i = 1; i < NUM_SEGMENTI; ++i)
        {
            x[i] = x[i - 1] + d;
        }
    }

    double y[NUM_RETTE][NUM_SEGMENTI];
    const double r0 = 2.0f;
    // calcolo delle y
    for (int i = 0; i < NUM_RETTE; ++i)
    {
        for (int j = 0; j < NUM_SEGMENTI; ++j)
        {
            y[i][j] = funzione(x[j], c[i], r0);
        }
    }

    // stampare a video
    for (int i = 0; i < NUM_RETTE; ++i)
    {
        for (int j = 0; j < NUM_SEGMENTI; ++j)
        {
            printf("c=%f, r=%f, x=%f, y=%f\n", c[i], r0, x[j], y[i][j]);
        }
    }
#undef NUM_SEGMENTI
#undef NUM_RETTE
}

double funzione(double x, double c, double r)
{
    return x * c + r * sin(c * c + 1);
}

Nota che si potevano fare altre modifiche, per esempio si può spostare l'inizializzazione in una funzione esterna e fare

#include <math.h>
#include <stdio.h>

/**
 * Data la famiglia di rette 
 *     \[\{ f_{c,\ r} = cx + r\sin(c^2 + 1) \colon c, r \in \mathbf{R} \},\]
 * questa funzione calcola il valore della funzione $f_{c,r}$ nel punto $x$.
 */
double funzione(double x, double c, double r);

/**
 * Inizializza un array con una progressione aritmentica
 */
void inizializza(double a[], unsigned int size, double start, double step);

int main(void)
{
#define NUM_RETTE (5)
    double c[NUM_RETTE];
    inizializza(c, NUM_RETTE, 0.1, 0.1);

#define NUM_SEGMENTI (10)
    double x[NUM_SEGMENTI];
    inizializza(x, NUM_SEGMENTI, 0.0, (1.0 / NUM_SEGMENTI));

    double y[NUM_RETTE][NUM_SEGMENTI];
    const double r0 = 2.0;

    for (int i = 0; i < NUM_RETTE; ++i)
    {
        for (int j = 0; j < NUM_SEGMENTI; ++j)
        {
            y[i][j] = funzione(x[j], c[i], r0);
        }
    }

    for (int i = 0; i < NUM_RETTE; ++i)
    {
        for (int j = 0; j < NUM_SEGMENTI; ++j)
        {
            printf("c=%f, r=%f, x=%f, y=%f\n", c[i], r0, x[j], y[i][j]);
        }
    }

#undef NUM_RETTE
#undef NUM_SEGMENTI
}

double funzione(double x, double c, double r)
{
    return x * c + r * sin(c * c + 1);
}

void inizializza(double a[], unsigned int size, double start, double step)
{
    a[0] = start;
    for (unsigned int i = 1; i < size; ++i)
    {
        a[i] = a[i - 1] + step;
    }
}

[Zyzzoy]

/* inizializzazione x */
    x[0] = 0.0;
    {
        int i;
        const double d = 1.0 / NUM_SEGMENTI;
        for (i = 1; i < NUM_SEGMENTI; ++i)
        {
            x[i] = x[i - 1] + d;
        }
    }

Nel primo esercizio quelle graffe senza ciclo servono a qualcosa o si possono omettere?

y[i][j] = funzione(x[j], c[i], r0);

Questa è una matrice vero? Noi non le abbiamo fatte!

}

#undef NUM_RETTE
#undef NUM_SEGMENTI
}

#undef cosa sarebbe?

Comunque ti ringrazio per la disponibilità, conosci un testo dove ci sono le basi del c di semplice interpretazione? Se cerco su internet una cosa (come per esempio quella di questa domanda) mi dà 100 versioni diverse e non saprei distinguere da un c++ a un c o gnu (non so cosa sia). Io penso che usiamo l'ANSI c, ma non so se sia una normativa o cosa, ne so come funziona. Nel nostro corso son state fatte solo esercitazioni senza teoria (e la poca teoria spiegata veramente male). Io so come svolgere a macchinetta pezzi degli esercizi che mi dà, ma se cambia qualcosa già non so dove mettere le mani, come in questo caso che penso sia una cosa banale questa.Quello che so lo so grazie ai tutorial di c di un ragazzo su youtube e esercizi ormai imparati a memoria a forza di farli.

[vict85]

Siccome conosco il C e il C++ da 17 anni, non saprei fornirti una buona guida. Io avevo studiato su un libro del C++ che ormai è datatissimo (il C++ è stato quasi completamente rivoluzionato nel 2011) e avevo pian piano scoperto le differenze con il C. Lo standard del 2011 del C, seppur sia stato meno rivoluzionario di quello del C++, è stato recepito in maniera positiva (al contrario di quello del 1999) quindi la maggior parte dei libri attuali lo useranno (o per lo meno non si preoccuperanno di un paio di limitazioni dell'ANSI C che venivano considerate antiquate già quando ho imparato il C io). Molti amanti del C considerano "The C Programming Language" (Second Edition) di Brian Kernighan e Dennis Ritchie come il libro su cui si dovrebbe studiare il C. Sinceramente io non l'ho usato e trovo il fatto che non sia stato aggiornato alle nuove versioni del linguaggio in grosso limite. Per esempio, il libro non terrà sicuramente conto del fatto che alcune funzioni di I/O sono attualmente deprecate, rimosse o comunque considerate poco sicure.

L'istruzione per il preprocessore [inline]#undef[/inline] serve ad annullare un [inline]#define[/inline]. La puoi ignorare.

Riguardo alla matrice/array multidimensionale, sì è una matrice/array multidimensionale. L'uso base lo puoi vedere lì. Di fatto non è altro che un array di array. Il mio comunque era solo un esempio, si può stampare direttamente il risultato a video invece di memorizzarlo oppure mettere due cicli non annidati all'interno del ciclo delle rette e memorizzare gli y per le varie rette in maniera indipendente.

Riguardo alle parentesi graffe, penso possa essere utile una spiegazione un po' più dettagliata. Una istruzione composta (spesso detta blocco di codice) consiste in una sequenza di definizioni e istruzioni racchiuse tra parentesi graffe. In generale, puoi mettere istruzioni composte ogni qual volta puoi usare istruzioni semplici (insomma una espressione seguita da ; ). Un esempio di questo "scambio" lo puoi vedere con if, for, switch, while e do.

Per capirci

for( i = 0; i < 3; i++ )
printf( "1" );
printf( "2" );

stampa a video "1112" (non ho indentato i due printf per non creare confusione), mentre

for( i = 0; i < 3; i++ )
{
    printf( "1" );
    printf( "2" ):
}

stampa "121212".

Una differenza tra C89 e gli standard successivi è che questi ultimi permettono di ordinare definizioni/dichiarazioni e istruzioni in qualsiasi ordine all'interno del blocco. Nel C89, le definizioni/dichiarazioni devono/dovevano precedere ogni istruzione.

Una cosa importante da sapere sulle istruzioni composte è che ogni variabile dichiarata in quell'istruzione è visibile SOLO all'interno del blocco stesso. In un certo senso puoi pensare che quella variabile viene creata nel momento in cui viene definita e poi distrutta alla fine del blocco. A livello professionale, definire le variabili solo quanto ti servono esplicitamente e restringere il loro "scope" il più possibile è considerata una buona prassi (da una parte aiuta il compilatore a capire quando non hai più bisogno di qualcosa e dall'altro evita alcuni errori che possono capitare quando recicli variabili). Nel mio esempio precedente, stavo evitando di riutilizzare gli indici dei cicli. Nota che con gli standard successivi al C89, è possibile definire variabili direttamente nella fare si inizializzazione del for.

[Zyzzoy]

se voglio ottenere 1112 in output posso fare:

for( i = 0; i < 3; i++ ){
printf( "1" ); }
printf( "2" );

per ottenere 121212

for( i = 0; i < 3; i++ )
{
    printf( "1" );
    printf( "2" ):
}

Io intendevo ste graffe quà fuori che racchiudono le costanti e il ciclo for a cosa servono

{
        int i;
        const double d = 1.0 / NUM_SEGMENTI;
        for (i = 1; i < NUM_SEGMENTI; ++i)
        {
            x[i] = x[i - 1] + d;
        }
    

Servono solo per dire che le verabili definite e la variabile inizializzata d e il contatore i valgono solo all'interno del ciclo e fuori non son nè definite nè inizializzate? Il prof a volte in alcuni esercizi faceva cicli for come questo:

for( i = 0; i < 3; i++ )
printf( "1" );
printf( "2" );

Senza alcuna parentesi graffa, se le scordava o è un modo alternativo?

[vict85]

Le parentesi graffe formano quello che viene chiamato una istruzione composta o blocco. Ogni istruzione composta è vista come una unica istruzione e ogni variabile al suo interno è locale a quel blocco.

Per capirci,

int main( void )
{
    { int i; }
    i = 2;
}

non compilerà. L'errore sarà che

i

non è definita (perché è locale del blocco in cui è definita). Nel codice di qualche messaggio fa, ho messo quelle parentesi per restringere la variabile [inline]i[/inline] al solo ciclo.

Il discorso relativo al for era solo per dire che il for faceva il ciclo sulla prima istruzione che lo seguiva, complessa o semplice che sia. Quindi se non metti le parentesi, ti esegue una sola espressione. Non avevo dimenticato alcune parentesi. Ma non metterle è spesso fonte di errore, quindi è utile sapere cose succede se non le metti, ma è sempre meglio metterle.

[Zyzzoy]

Immagino che ti darà anche l errore che i non è usata. Non capisco che fastidio dia al programma se dichiari variabili senza poi usarle. Quindi l'assenza delle parentesi col ciclo for era voluta dal prof quando il for doveva eseguire una sola istruzione messa dopo il for stesso. Domani faccio un salto in biblioteca per vedere se c'è qualche buon libro e iniziare a studiare ,dopo il 5/30 preso all'esame. Meccanica razionale è una passeggiata in confronto a sta roba, possibile che debba perdere cosi tanto tempo con una materia che non centra nulla con il mio corso? Comunque ti ringrazio per l'aiuto che mi hai dato e sopratutto per la pazienza !