undefined reference to main()

[Metallica]

#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]

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]

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]

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.





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

[Metallica]

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]

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]

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]

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]

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]

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