PDA

Visualizza la versione completa : undefined reference to main()


Metallica
12-12-2003, 18:45
#include<stdio.h>
#include<malloc.h>

int horner(float coeff[], int n, int c)

main()
{
/* DICHIARAZIONE VARIABILI */
int n, i, c;
float *coeff;

coeff = (float *)malloc(n*sizeof(float));

/* LETTURA GRADO DEL POLINOMIO */
printf("Inserire il grado del polinomio");
scanf("%d", &n);

/* INSERIRE I VALORI DEI COEFF */
printf("Inserire uno ad uno i valori dei coefficienti a:");
for(i=0; i<=n; i++){
printf("Inserire il valore del coeff %d", i);
scanf("$f", &coeff[i]);
}

horner(coeff, n, c);
printf("%d",horner);

free(coeff);
}

int horner(float coeff[], int n, int c)
{
int i;
int horner;
horner = coeff[n];
for (i=n-1; i>=0; i--)
horner = horner * c + coeff[i];
return horner;
}

infinitejustice
12-12-2003, 19:38
int horner(float coeff[], int n, int c)

Quando dichiari un prototipo di funzione nn c' bisogno di mettere i nomi delle variabili. Ricordati il ; e per l'array basta un puntatore :)

int horner(float *, int, int);


Il main() dichiaralo void se nn ritorna nulla, se no lo considera int e vuole il valore di ritorno (se setti -Wall dovrebbe segnalartelo).



A parte questo l'unico vero errore c che tu passi come parametro alla funzione senza averlo mai inizializzato.

Metallica
12-12-2003, 19:52
sto apsettando ancora un libro sul C. quindi per ora sono bloccato.
Saresti cos gentile da spiegarmi come lo scriveresti tu senza errori.
Mi s che non ho capito molto.

infinitejustice
12-12-2003, 20:01
Basta che inizializzi la variabile c

A parte questo ti do solo questo consiglio: quando allochi memoria controlla sempre che l'allocazione sia avvenuta correttamente.

if(!(coeff = (float *)malloc(n*sizeof(float))))
abort();

Con questa riga allochi memoria e nel caso in cui fallisca il programma salta.

:ciauz:



p.s. se lo provi ti salta e ti accorgi di un errore nell'allocazione di memoria ;)

Metallica
12-12-2003, 20:09
a te lo compila non vorrei fosse un errore della mia macchina


#include<stdio.h>
#include<malloc.h>

int horner(float *, int, int)

main()
{
/* DICHIARAZIONE VARIABILI */
int n, i, c;
float *coeff;

if(!(coeff = (float *)malloc(n*sizeof(float))))
abort()

/* LETTURA GRADO DEL POLINOMIO */
printf("Inserire il grado del polinomio");
scanf("%d", &n);

/* INSERIRE I VALORI DEI COEFF */
printf("Inserire uno ad uno i valori dei coefficienti a:");
for(i=0; i<=n; i++){
printf("Inserire il valore del coeff %d", i);
scanf("$f", &coeff[i]);
}
scanf("%d",&c);
horner(coeff, n, c);
printf("%d",horner);

free(coeff);
}

int horner(float *, int, int)
{
int i;
int horner;
horner = coeff[n];
for (i=n-1; i>=0; i--)
horner = horner * c + coeff[i];
return horner;
}

infinitejustice
12-12-2003, 20:12
A parte che hai dimanticato qualche punto e virgola

Gli errori sono due, identici. Utilizzi variabili prima di inizializzarle.

int x una dichiarazione di variabile, ma nn ha senso dire y = x.
Allo stesso modo nn ha senso passare c ad una funzione (Che valore gli passi se nn gli hai dato valore?) ne tantomeno allocare n*sizeof() memoria se n viene inizializzato dopo.

Dai un valore a c e assegna un valore a n prima dell'allocazione di coeff

infinitejustice
12-12-2003, 20:20
int horner(float *, int, int)
Manca il punto e virgola.



main()

main() considerato dalla macchina come int main();
Quindi o dichiari void main() oppure il main() deve avere un valore di ritorno


coeff = (float *)malloc(n*sizeof

n viene inizializzata nella riga sotto, quindi al momento nn ha alcun valore, quindi errato (se provi infatti il programma va in abort).

Prima chiedi il grado del polinomio quindi malloca coeff :)


Allo stesso modo dai un valore a c prima di passarlo alla funzione come parametro


A prima vista nn mi sembra ci sia altro, forse qualche altro punto e virgola

Metallica
12-12-2003, 22:02
cmq ho il ridotto un po' il num di errori:



/*NUOVO PROGRAMMA*/
#include<stdio.h>
#include<malloc.h>

int horner(float *coeff[], int n, int c);

main()
{
/* DICHIARAZIONE VARIABILI */
int n, i, c;
float *coeff;

/* LETTURA GRADO DEL POLINOMIO */
printf("Inserire il grado del polinomio");
scanf("%d", &n);

if(!(coeff = (float *)malloc(n*sizeof(float))))
abort();

/* INSERIRE I VALORI DEI COEFF */
printf("Inserire uno ad uno i valori dei coefficienti a:");
for(i=0; i<=n; i++){
printf("Inserire il valore del coeff %d", i);
scanf("$f", &coeff[i]);
}
scanf("%d",&c);
horner(coeff, n, c); /*############# questa la linea 26 #########*/
printf("%d",horner);

free(coeff);
}

int horner(float *coeff[], int n, int c)
{
int i;
int horner;
horner = coeff[n]; /*############ questa linea 36 ###############*/
for (i=n-1; i>=0; i--)
horner = horner * c + coeff[i];
return horner;
}


e gli errori sono:


[mariano@localhost mariano]$ gcc -o horner main.c
main.c: In function `main':
main.c:26: warning: passing arg 1 of `horner' from incompatible pointer type
main.c: In function `horner':
main.c:36: warning: assignment makes integer from pointer without a cast
main.c:38: warning: assignment makes integer from pointer without a cast

infinitejustice
12-12-2003, 22:38
Serve la libreria stdlib.h per usare abort()
#include <stdlib.h>

int horner(float *coeff[], int n, int c);
Uhmmm hai chiaro il modo in cui lavorare coi puntatori sugli array?

La dichiarazione corretta float *coeff

Un array un insieme di n elementi ordinati tutti dello stesso tipo. Ci significa che se hai l'indirizzo di memoria del primo puoi accedere agli altri.

Quindi array[i] equivale a *(array+i)

Il main() dichiaralo come void main() se no serve un valore di ritorno.

for(i=0; i<=n; i++){

La condizione deve fermarsi a i < n
Ricordati che i parte da 0, non da 1.

int horner(float *coeff[], int n, int c)

La dichiarazione corretta *coeff. Se no dichiari un array di puntatori a float di dimensione sconosciuta.


Ora dovrebbe compilare correttamente (ma nn lho provato)

infinitejustice
12-12-2003, 22:54
Questo il codice completo, funziona senza errori (ne ho trovati un altro paio)


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

int horner(float *coeff, int n, int c);

void main(){

int i, c, n;
float *coeff;

printf("Inserire il grado del polinomio: ");
scanf("%d", &n);

if(!(coeff = (float *)malloc(n*sizeof(float))))
abort();

printf("\nInserire uno ad uno i valori dei coefficienti: ");
for(i = 0; i < n; i++){
printf("\nInserire il valore del coeff %d: ", i+1);
scanf("%f", &coeff[i]);
}

printf("\nInserisci il valore di c: ");
scanf("%d",&c);

printf("%d", horner(coeff, n, c));

free(coeff);
}

int horner(float *coeff, int n, int c){

int i, horner;

horner = coeff[n];
for(i = n-1; i > 0; i--)
horner = horner * c + coeff[i];

return horner;
}


p.s. quando chiami una funzione che ha valore di ritorno, o assegni il valore ritornato ad una variabile o lo stampi.

Cio:
horner(coeff, n, c);
printf("%d",horner);

Non ha molto senso. La prima riga ok sintatticamente, ma nn sfrutti il valore di ritorno. Nel secondo caso vuoi farglielo stampare chiamando la funzione ma nn le passi i parametri.

Quindi o fai una cosa tipo x = horner(coeff, n, c); e poi stampi x o fai come nel codice che ti ho postato nel quale stampa direttamente

:ciauz:

Loading