warum muss eine const VAriable unumgänglich nur über die INitialisierungsliste
definiert werden ? könnte man doch gleich

class a{

private:

const int variable=7;

}

Ich kann mich aber nicht erinnern, jemals const auf diese Art in einer Klasse vernünftig benutzt zu haben.

class Komplex
   {
     private:
       double re, im;

     public:
       Komplex(void)
       {
         re = im = 0.0;
       }
       // Typumwandlungskonstruktor double -> Komplex
       Komplex(double r)
       {
         re = r;
         im = 0.0;
       }

       // weitere moegliche Alternativen:
       //   Komplex(const double r);
       //   Komplex(double & r);
       //   Komplex(const double & r);

       // Typumwandlung double * in Komplex:
       //   Komplex(double * r);
       ...
   };
Versteh nicht wozu der gut sein soll

Ich seh keinen Unterschied zum normalen Konstruktor. Der sieht doch genauso aus

class complex {
  double real_;
  double imag_;
public:
  complex(double r=0, double i=0) : real_(r), imag_(i) {}
};

void foo(complex t);

int main() {
  complex c = 23; // Kopierinitialisierung von c
  foo(42); // Kopierinitialisierung des Parameters t
}

stichworte zum verbessern deiner klasse wären:
initialisierungsliste
explicit

struct komplex
{
 komplex() //das void in klammern lässt man in c++ üblicherweise weg
 : im(0.), re(0.) //initailisierungsliste - 0. ist kurz für 0.0 und das ist die double-0. sonst würde erst noch eine konvertierung von int in double geschehen, was dir ein compiler als warnung ausgeben könnte
 {}

 komplex(double real)
 : im(0.), re(real)
 {}

 komplex(double real, double imag)
 : im(imag), re(real)
 {}

private:
 double im;
 double re;
};

uns fällt nun auf, dass alle 3 konstruktoren fast identisch sind, also wieso 3 verschiedene?

struct komplex
{
  komplex(double re = 0., double im = 0.)
  : re(re), im(im)
  {}

private:
  double re;
  double im;
};

ich würde den konstruktor hier nicht explicit machen, aber das ist wohl geschmackssache, deshalb hatte ich es mal erwähnt.

bb

aha und wo ist jetzt der Konvertierungskonstruktor ?
sowohl re also im sind vom typ double. Kommt der Konvertierungskonstruktor
wenn ich z.B einen int übergebe oder wann

struct komplex
{
  komplex(double r = 0., double i = 0.)
  : r(r), i(i)
  {}

private:
  double r, i;
};

dieser eine konstruktor kann all das hier:

int main()
{
  komplex c0;
  komplex c1(1.5); //deine gewünschte konvertierung
  komplex c2(1.5, 1.0);
}

oder um es vll klarer zu machen:

komplex function()
{
  double return_value = 2.0;

  return return_value; //hier wird der ctor komplex(double,double) aufgerufen. mit den werten(2.0, 0.0)
}

ist ein dummes bsp., aber daran sollte es klar werden!?

bb

der Konstruktor verlangt einen double Wert. Und er bekommt doch auch einen.

komplex c1(1.5); //deine gewünschte konvertierung

#include <iostream>

void funkt(double x) {  }  

void main(void)  {

int x;

  funkt((double)x);  // hier wird konvertiert

}

damit konvertiert er einen double in eine komplexe zahl.

natürlich ist auch die umwandlung von int in double eine konvertierung, aber die geschieht ohnehin automatisch(das kennt dein compiler schon - aber eine konvertierung von double/int/... in eine selbst geschriebene klasse... kann er ja kaum erraten - und genau deshalb muss man ihn dort schreiben, wenn man ihn haben möchte)

bb