Трабла с конвертированием кода изи Дельфи

[pascal]
unit uRand;

interface

type
TRandomGenerator = class
public
a,b,dx : double;
Mv, Dv, Gv : double;
Constructor Create(a, b : double);
function NewX : double; virtual; abstract;
end;

T3RaspGenerator = class(TRandomGenerator)
public
Constructor Create(a,b : double; n : Integer);

function NewX : double; override;
end;

TNormalGenerator = class(TRandomGenerator)
public
kol : Integer;
Constructor Create(a,b : double; kol : Integer; n : Integer);

function NewX : double; override;
end;

TExponentaGenerator = class(TRandomGenerator)
public
l : double;
Constructor Create(a,b : double; l : double; n : Integer);

function NewX : double; override;
end;

TErlangGenerator = class(TRandomGenerator)
public
kol : integer;
exponenta : TExponentaGenerator;
Constructor Create(a,b : double; l : double; kol, n : Integer);

function NewX : double; override;

Destructor Destroy; override;
end;

type d_array = array of double;

THiperExsponentaGenerator = class(TRandomGenerator)
public
kol : integer;
p_array : d_array;
exponents : array of TExponentaGenerator;
Constructor Create(a,b : double; kol, n : Integer; l,p : d_array);

function NewX : double; override;

Destructor Destroy; override;
end;

implementation

{ TRandomGenerator }

Constructor TRandomGenerator.Create(a,b : double);
begin
Randomize();

self.a:= a;
self.b:= b;

Mv:= (a + b) / 2;
Dv:= sqr(a - b) / 12;
end;

Constructor T3RaspGenerator.Create(a,b : double; n : Integer);
begin
Inherited Create(a, b);

Mv:= Mv * 2;
Dv:= Dv * 2;

Gv:= sqrt(Dv);

dx:= 2 / Gv / n;
end;

function T3RaspGenerator.NewX : double;
var v,z,x : double;
begin
v:= random + random;
z:= (v - Mv) / Gv;
x:= z + 3;

result:= x;
end;

Constructor TNormalGenerator.Create(a,b : double; kol : Integer; n : Integer);
begin
self.kol:= kol;
Inherited Create(a, b);

Mv:= Mv * kol;
Dv:= Dv * kol;

Gv:= sqrt(Dv);

dx:= kol / Gv / n;
end;

function TNormalGenerator.NewX : double;
var v,z,x : double;
i : Integer;
begin
v:= 0;
for i:= 1 to kol do
v:= v + random;

z:= (v - Mv) / Gv;
x:= z + 3;

result:= x;
end;

Constructor TExponentaGenerator.Create(a,b : double; l : double; n : Integer);
begin
self.l:= l;
Inherited Create(a, b);

Mv:= 3;
Gv:= 1;

dx:= (b - a) / n;
end;

function TExponentaGenerator.NewX : double;
var x : double;
begin
Repeat
x:= random;
Until x<>0;

result:= - ln(x) / l;
end;

Constructor TErlangGenerator.Create(a,b : double; l : double; kol, n : Integer);
begin
exponenta:= TExponentaGenerator.Create(a,b,l,n);
self.kol:= kol;
Inherited Create(a, b);

Mv:= 3;
Gv:= 1;
dx:= (b - a) / n;
end;

function TErlangGenerator.NewX : double;
var x : double;
i : Integer;
begin
x:= 0;

for i:= 1 to kol do
x:= x + exponenta.NewX();

result:= x;
end;

Destructor TErlangGenerator.Destroy;
begin
exponenta.Free;
end;

Constructor THiperExsponentaGenerator.Create(a,b : double; kol, n : Integer; l,p : d_array);
var i : Integer;
begin
SetLength(exponents, kol + 1);
for i:= 1 to kol do
exponents[i]:= TExponentaGenerator.Create(a,b,l[i],n);
self.kol:= kol;
self.p_array:= p;
Inherited Create(a, b);

Mv:= 3;
Gv:= 1;
dx:= (b - a) / n;
end;

function THiperExsponentaGenerator.NewX : double;
var x : double;
i : Integer;
begin
x:= 0;

for i:= 1 to kol do
x:= x + exponents[i].NewX()*p_array[i];

result:= x;
end;

Destructor THiperExsponentaGenerator.Destroy;
var i : Integer;
begin
for i:= 1 to kol do
exponents[i].Free;
end;

end.
[/pascal]

Хедер:

[c++]
class TRandomGenerator
{
private: // User declarations
protected:
double astor,bstor;
public: // User declarations
double dx, Mv, Dv, Gv;
TRandomGenerator(double a, double b);
virtual double NewX() = 0;
};

class T3RaspGenerator : public TRandomGenerator
{
public:
T3RaspGenerator(double a, double b, int n);
virtual double NewX();
};

class TNormalGenerator : public TRandomGenerator
{
public:
int kol;
TNormalGenerator(double a, double b, int kol, int n);
virtual double NewX();
};

class TExponentaGenerator : public TRandomGenerator
{
public:
double l;
TExponentaGenerator(double a, double b, double l, int n);
virtual double NewX();
};

class TErlangGenerator : public TRandomGenerator
{
public:
int kol;
TExponentaGenerator exponenta;
TErlangGenerator(double a, double b, double l, int kol, int n);
virtual double NewX();
~TErlangGenerator();
};
....

Дальше не делал т.к. возникает ошибка...читаем описание дальше
[/c++]
==========================================================================================================

Описание(тело):

[c++]
andomGenerator::TRandomGenerator(double a, double b): astor(a), bstor(b)
{
randomize();
this->astor = a;
this->bstor = b;
Mv = (a + b) / 2;
Dv = pow( (a - b), 2) / 12;
}
//---------------------------------------------------------------------------

T3RaspGenerator::T3RaspGenerator(double a, double b, int n) : TRandomGenerator(a,b)
{
Mv = Mv * 2;
Dv = Dv * 2;

Gv = sqrt(Dv);

dx = 2 / Gv / n;
}
//---------------------------------------------------------------------------

double T3RaspGenerator::NewX()
{
double v,z,x;
v = random(1) + random(1);
z = (v - Mv) / Gv;
x = z + 3;
return x;
}
//---------------------------------------------------------------------------

TNormalGenerator::TNormalGenerator(double a, double b, int kol, int n) : TRandomGenerator(a,b)
{
this->kol = kol;
Mv = Mv * kol;
Dv = Dv * kol;
Gv = sqrt(Dv);
dx = kol / Gv / n;
}
//---------------------------------------------------------------------------

double TNormalGenerator::NewX()
{
double v,z,x;
v = 0;
for( int i= 1; i<=kol; i++)
v = v + random(1);
z = (v - Mv) / Gv;
x = z + 3;
return x;
}
//---------------------------------------------------------------------------

TExponentaGenerator::TExponentaGenerator(double a, double b, double l, int n) : TRandomGenerator(a,b)
{
this->l = l;
Mv = 3;
Gv = 1;
dx = (b - a) / n;
}
//---------------------------------------------------------------------------

double TExponentaGenerator::NewX()
{
double x;
do
x = random(1);
while (x!=0);
return - log(x) / l;
}

ТУТ СТОП! НЕ МОГУ ПОНЯТЬ! КАК ОПИСАТЬ
TErlangGenerator::TErlangGenerator(...
[/c++]

Поясню, надо както перегнать код Дельфи, в С++:

[pascal]
Constructor TErlangGenerator.Create(a,b : double; l : double; kol, n : Integer);
begin
exponenta:= TExponentaGenerator.Create(a,b,l,n);
self.kol:= kol;
Inherited Create(a, b);

Mv:= 3;
Gv:= 1;
dx:= (b - a) / n;
end;
[/pascal]


Пробую так:
(говорит ошибку, во второй строке
E2279 Cannot find default constructor to initialize member 'TErlangGenerator::exponenta'
[C++ Error] uGen.cpp(103): E2314 Call of nonfunction)
[c++]
TErlangGenerator::TErlangGenerator(double a, double b, double l, int kol, int n) : TRandomGenerator(a, b)
{
exponenta= TExponentaGenerator(a,b,l,n);
//this->kol = kol;
//Mv = 3;
//Gv = 1;
//dx = (b - a) / n;
}
[/c++]