ich bekomme beim Kompilieren meines Programmes folgende Fehlermeldung :

error: candidates are: int stn14o::nelmin(double ()(double), int, double*, double*, double, double, double*, int, int, int, int, int, double, double)

error: no matching function for call to `stn14o::nelmin(double, int&, double[2], double*&, double&, double&, double[2], int&, int&, int&, int&, int&, double, double)

Kann mir das jemand erklären ?

VIELEN DANK im Voraus

Geiler Funktionsname (und noch geiler vom Scope)

Ich finde die Anzahl der Übergabeparameter viel interessanter.

Wieso immer int& oder double& und nicht einfach int oder double,
so wie die Funktion halt definiert worden ist ?!?!?!

Bei den letzten beiden Parametern handelt es sich um Zahlen, bei
den übrigen um Variable, die zuvor mit Werten zugewiesen wurden.

Wieso sieht der Compiler die Parameter immer mit Adressen von Datentypen ????

Das sind Referenzen, keine Adressen.

Einzelne Fragezeichen tun's auch.

void stn14o::clear(){
double g,am1,*start,*step;
double reqmin = 1.0e-10,*xmin,xminval=0,ynewlo,*x,xval=0;
int n=3,konvge=5,kcount=2000,ifault=0,icount,numres;

//code

nelmin(f(x), n, start, xmin, ynewlo, reqmin, step,konvge, icount, kcount, numres, ifault,1.0e-8, 1.0e-8);

}

int stn14o::nelmin(double fn(double *x),int n,double *start,double *xmin,double ynewlo,double reqmin,double *step,int konvge,int icount,int kcount,int numres,int ifault,double reltol, double abstol){

//code

}

double stn14o::f(double *x){

//code

}

Wieso immer int& oder double& und nicht einfach int oder double,
so wie die Funktion halt definiert worden ist ?!?!?!

der compiler zeigt dir die funktion so an, wie sie definiert wurde, das ist der candidate.
die zweite funktion (mit den referenzen etc.) ist der funktionstyp, der am besten zu deinen aufrufparametern passt. in dieser form muss die funktion nicht existieren, es ist lediglich ein 'best match'.

Vorschläge (schriebt ruhig code rein) ?

VIELEN DANK im Voraus

prinzipiell:

int stn14o::nelmin(
double fn(double *x),
int n,
double *start,
double *xmin,
double ynewlo,
double reqmin,
double *step,
int konvge,
int icount,
int kcount,
int numres,
int ifault,
double reltol, 
double abstol);

double func ( double* ) {return 0;}
int n;
double start;
double xmin;
double ynewlo;
double reqmin;
double step;
int konvge;
int icount;
int kcount;
int numres;
int ifault;
double reltol;
double abstol;

nelmin ( 
func,
n,
&start,
&xmin,
ynewlo,
reqmin,
&step,
konvge,
icount,
kcount,
numres,
ifault,
reltol, 
abstol
);

Es muss doch noch einen Weg geben, mit der die Funktion func so ausseht

"double func(double *x)"

..

double func(double *x) { return 0; }

dann schreib es doch einfach rein.

double func(double *x) { return 0; }

was dazu führen würde, dass der compiler sagt "unused variable"
deswegen hab ichs rausgelassen

aber wie miller richtig sagt... wenn du sie benutzen willst
schreib sie rein wenn nich lass sie weg

Trotzdem bekomme ich aber folgende Fehlermeldung :

error: no matching function for call to `stn14o::nelmin(<unknown type>, int&, double*&, double*&, double&, double&, double*&, int&, int&, int&, int&, int&, double, double)

error: candidates are: int stn14o::nelmin(double ()(double), int, double*, double*, double, double, double*, int, int, int, int, int, double, double)

Als ersten Parameter hab ich jetzt nur "func" stehen.

int nelmin( 
double fn(double *x), 
int n, 
double *start, 
double *xmin, 
double ynewlo, 
double reqmin, 
double *step, 
int konvge, 
int icount, 
int kcount, 
int numres, 
int ifault, 
double reltol, 
double abstol){return 0;}

double func ( double* ) {return 0;} 
int n; 
double start; 
double xmin; 
double ynewlo; 
double reqmin; 
double step; 
int konvge; 
int icount; 
int kcount; 
int numres; 
int ifault; 
double reltol; 
double abstol; 

int main()
{

  nelmin ( 
  func, 
  n, 
  &start, 
  &xmin, 
  ynewlo, 
  reqmin, 
  &step, 
  konvge, 
  icount, 
  kcount, 
  numres, 
  ifault, 
  reltol, 
  abstol 
  ); 

  return 0;
}

[edit]
da fällt mir auf ich sollte mal wieder updaten

ich weiß zwar ned was du da machst aber wenn ich untenstehenden code in ne leere cpp kopier und mit visual c++ 6 kompilier werden keine fehler angezeigt

int nelmin( 
double fn(double *x), 
int n, 
double *start, 
double *xmin, 
double ynewlo, 
double reqmin, 
double *step, 
int konvge, 
int icount, 
int kcount, 
int numres, 
int ifault, 
double reltol, 
double abstol){return 0;}

double func ( double* ) {return 0;} 
int n; 
double start; 
double xmin; 
double ynewlo; 
double reqmin; 
double step; 
int konvge; 
int icount; 
int kcount; 
int numres; 
int ifault; 
double reltol; 
double abstol; 

int main()
{
  
  nelmin ( 
  func, 
  n, 
  &start, 
  &xmin, 
  ynewlo, 
  reqmin, 
  &step, 
  konvge, 
  icount, 
  kcount, 
  numres, 
  ifault, 
  reltol, 
  abstol 
  ); 

  return 0;
}

Diesmal ist wieder kein x als Parameter angegeben worden.
Ich wollte jedoch wissen, wie eine Lösung aussieht, wenn als Parameter
der Funktion func ein x steht , also "double func(doublex)" und nicht
"double func(double)".
Denn das x wird gebraucht, da die Variable in der Funktion bearbeitet wird.

Diesmal ist wieder kein x als Parameter angegeben worden.
Ich wollte jedoch wissen, wie eine Lösung aussieht, wenn als Parameter
der Funktion func ein x steht , also "double func(doublex)" und nicht
"double func(double)".
Denn das x wird gebraucht, da die Variable in der Funktion bearbeitet wird.

der funktionsaufruf sieht (mit oder ohne x) genauso aus tt

Diesmal ist wieder kein x als Parameter angegeben worden.
Ich wollte jedoch wissen, wie eine Lösung aussieht, wenn als Parameter
der Funktion func ein x steht , also "double func(doublex)" und nicht
"double func(double)".
Denn das x wird gebraucht, da die Variable in der Funktion bearbeitet wird.

ob x angegeben wird oder nicht sagt nur was drüber aus ob du die variable in der funktion verwenden kannst
es ändert die funktionalität des codes nicht

Kann es sein, dass die Ursache ganz wo anders im Code liegen kann ?
(Ist eigentlich immer die einzige Fehlermeldung des Kompilers)

include <stdio.h>
typedef	double (* fn)(double *x);

int nelmin(
        fn fp,
	int n,
	double *start,
	double *xmin,
	double ynewlo,
	double reqmin,
	double *step,
	int konvge,
	int icount,
	int kcount,
	int numres,
	int ifault,
	double reltol,
	double abstol){ fp(start); }

double func( double* x) { printf("st = %f\n", *x); return 0;}

int mm;
double st;
double xmin;
double ynewlo;
double reqmin;
double step;
int konvge;
int icount;
int kcount;
int numres;
int ifault;
double reltol;
double abstol;

int main() {
        st = 5.1;
	nelmin (func,
		mm,
		&st,
		&xmin,
		ynewlo,
		reqmin,
		&step,
		konvge,
		icount,
		kcount,
		numres,
		ifault,
		reltol,
		abstol ); 
}

Kurt

@zuk ne hat nix damit zu tun und warum bindest du eigentlich stdio.h ein?

@zuk ne hat nix damit zu tun

Ist mir klar dass es auch ohne typedef gehen sollte. Vielleicht spinnt sein compiler.

Sovok schrieb:

und warum bindest du eigentlich stdio.h ein?

Hab's als c-code ausprobiert ( wg printf ). Ok falsches Forum.
K

Hab's als c-code ausprobiert ( wg printf ). Ok falsches Forum.
K

stimmt hab ich überlesen
nix für ungut