void gauss_legendre_tbl(int n, double* x, double* w, double eps)
{
	double x0,  x1,  dx;	/* Abscissas */
	double w0,  w1,  dw;	/* Weights */
	double P0, P_1, P_2;	/* Legendre polynomial values */
	double dpdx;			/* Legendre polynomial derivative */
	int i, j, k, m;			/* Iterators */
	double t0, t1, t2, t3;

	m = (n+1)>>1;

	t0 = (1.0-(1.0-1.0/(double)n)/(8.0*(double)n*(double)n));
	t1 = 1.0/(4.0*(double)n+2.0);

	for (i = 1; i <= m; i++)
	{
		/* Find i-th root of Legendre polynomial */

		/* Initial guess */
		x0 = cos(PI*(double)((i<<2)-1)*t1)*t0;

		/* Newton iterations, at least one */
		j = 0;
		dx = dw = DBL_MAX;
		do 
		{
			/* Compute Legendre polynomial value at x0 */
			P_1 = 1.0;
			P0  = x0;
#if 0
			/* Simple, not optimized version */
			for (k = 2; k <= n; k++)
			{
				P_2 = P_1;
				P_1 = P0;
				t2 = x0*P_1;
				t3 = (double)(k-1)/(double)k;

				P0 = t2 + t3*(t2 - P_2);
			}
#else
			/* Optimized version using lookup tables */
			if (n<1024)
			{
				/* Use fast algorithm for small n*/
				for (k = 2; k <= n; k++)
				{
					P_2 = P_1;
					P_1 = P0;
					t2  = x0*P_1;

					P0 = t2 + ltbl[k]*(t2 - P_2);

				}

			}else{

				/* Use general algorithm for other n */
				for (k = 2; k < 1024; k++)
				{
					P_2 = P_1;
					P_1 = P0;
					t2  = x0*P_1;

					P0 = t2 + ltbl[k]*(t2 - P_2);
				}

				for (k = 1024; k <= n; k++)
				{
					P_2 = P_1;
					P_1 = P0;
					t2 = x0*P_1;
					t3 = (double)(k-1)/(double)k;

					P0 = t2 + t3*(t2 - P_2);
				}
			}
#endif
			/* Compute Legendre polynomial derivative at x0 */
			dpdx = ((x0*P0-P_1)*(double)n)/(x0*x0-1.0);

			/* Newton step */
			x1 = x0-P0/dpdx;

			/* Weight computing */
			w1 = 2.0/((1.0-x1*x1)*dpdx*dpdx);

			/* Compute weight w0 on first iteration, needed for dw */
			if (j==0) w0 = 2.0/((1.0-x0*x0)*dpdx*dpdx);

			dx = x0-x1;
			dw = w0-w1;

			x0 = x1;
			w0 = w1;
			j++;
		} while((FABS(dx)>eps || FABS(dw)>eps) && j<100);

		x[(m-1)-(i-1)] = x1;
		w[(m-1)-(i-1)] = w1;
	}

	return;
}

die hat unten zwei arrays X[] und w[] wo rauf ich von den main zugreifen will

wie definiere ich die zwei array in den main die ich an der funktion übergebe
und wie kann ich die zwei arrays in den main ausgeben
(das problem da ich ein zeiger übergebe und die große des array nicht kenne)

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <iostream>
#include <iomanip>
#include "gauss_legendre.h"
using namespace std;

#ifndef PI
	#define PI 3.1415926535897932384626433832795028841971693993751
#endif
int main()
{

return 0;
}

vielen danke

Aber immer noch kein C++, ist eher eine C Frage. Das einzige was da dran C++ ist, ist dass du aus unerfindlichen Gründen zwei Header aus C++ und eine using Directive benutzt hast, die du allesamt nirgendwo benutzt.

diese funktion gehört zu klasse gaus_legendre.cpp

Drücke dich korrekt aus. Das ist garantiert keine Klasse. Meinst du eventuell die Worte Quelldatei oder Bibliothek?

die hat unten zwei arrays X[] und w[] wo rauf ich von den main zugreifen will

Drücke dich korrekt aus. Die Funktion hat zwei Übergabeparameter vom Typ double*. Auf die kannst du von außen gar nicht zugreifen, denen kannst du bloß was übergeben, wenn du willst.

wie definiere ich die zwei array in den main die ich an der funktion übergebe

Entweder definierst du ein Array a la double array[5]; oder benutzt einen vector, falls du doch C++ machst. Falls du C machst und die Arrays sehr groß sind (Megabytes und größer), solltest du eventuell malloc benutzen.

und wie kann ich die zwei arrays in den main ausgeben

Drüber iterieren, ausgeben.

(das problem da ich ein zeiger übergebe und die große des array nicht kenne)

Dafür wird wohl das n gut sein. Das ist ein typisches Interface für C Funktionen: Der Benutzer stellt den Speicherplatz und übergibt dann den Speicherplatz und die Größe an die Funktion, diese füllt den Speicherplatz mit den Ergebnissen (oder nutzt die Werte die schon drinstehen). Das heißt, die Größe muss in der main bekannt sein, denn dort leben auch die Arrays. Das sollte aber auch dokumentiert sein, wie man die Funktion benutzt.

P.S.: Der Code der Funktion sieht übrigens nicht sehr vertrauenserweckend aus. Viel "Magie", wo der Programmierer wohl mal gesehen hat, wie man manche Sachen richtig macht, aber nicht verstanden hat. Nicht direkt falsch, aber man erkennt, dass das tiefere Sprachverständnis fehlt. Numerische Integrationsbibliotheken gibt es haufenweise und viele sind sicherlich besser. Guck dir zum Beispiel mal die GSL an (gibt aber auch andere), die ist wesentlich professioneller und auf vielen Plattformen zum wissenschaftlichen Rechnen schon vorhanden.

int main{
        int n = 10;//eingabe parameter
	int s = 10;// um zu testen ob der zugriff geht setze ich die array große auf 10
	double *px ;
	px = new double[s] ;
	double *w = new double[];
	double eps = 1e-10;
	cout<<"test"<<endl;
	gauss_legendre_tbl(n,px,w,eps);// funktion aufruf

	 for ( int i = 0; i < s; i++)
   {
     cout << "  " << px[i] << endl;
   }
return 0;

ich kann auf die daten zugreifen aber das problem ich habe hier die große Auf
s =10 gesetzt.
da ich vorher nicht weiß wie große mein array ist weiße ich nicht wie ich drauf zugreife
vielen danke

Da ich vorher nicht weiß wie groß mein Array ist weiß ich nicht wie ich drauf zugreife

Ja.. hä? Wie könntest du auch nicht wissen wie groß das Array ist, du legst es doch selbst an?

Welcher Compiler frisst das?

Und wenn du C++ machen willst, dann nimm vector, kein new[]! Du hättest dir nämlich in deinem Programm prompt ein Speicherloch gemacht, wenn es denn überhaupt funktionieren würde.

Ist die Funktion eigentlich von dir, oder ist die aus irgendeiner Bibliothek? Falls sie nämlich von dir ist, solltest du sie einfach mit std::vector umschreiben, dann wird das alles trivial.

Was soll das bringen?

#if 0
//....
#else
//...
#endif

Was soll das bringen?

Eine Art Debugcode. Der Autor möchte zeigen, wie es früher war, bevor er es optimiert hat. Da sich C-Kommentare nicht schachteln lassen und C++-Kommentare für jede Zeile nervig sind (und in C89 ganz streng genommen auch nicht vorhanden sind, ist das eine effektive Art, schachtelbare Kommentare in C umzusetzen.