überschreiben Konstruktor c++

Habe ich abstrakte Klasse Eine

class A{
 public:
  A(dim) : dim_(dim);
 private:
  int dim_;
}

Klasse B

class B : public A{
 public:
  B(int dim);
}

und ich brauche, um Konstruktor für die Klasse B, die nur funktioniert, wenn dim > 1, und werfen Behauptungen sonst.

in diesem Fall

B::B(int dim) : A(dim){
  assert(dim > 1);
}

es funktioniert, aber es ist keine gute Lösung denke ich, da die Instanz der Klasse A wurde angelegt und gelöscht werden.

Als ich die init-Methode für die Klasse A:

class A{
 public:
  void init(int dim){
    dim_ = dim;
  }
  A(int dim){
    init(dim);
  }
 private:
  int dim_;
}

und ändern Konstruktor der Klasse B:

class B : public A {
 public:
  B(int dim){
    assert(dim > 1);
    init(dim);
  }
}

aber es funktioniert nicht. Gibt es mögliche Lösungen für mein problem?

Klasse A ist nicht abstract...
irgendwie habe ich das Gefühl, dass sich auf 'dim' in deinem Tor ist der falsche Ansatz.

InformationsquelleAutor user1761982 | 2013-01-05

  1. 5

    Ich glaube, Sie könnten schreiben Sie eine kleine myint Klasse, die dafür sorgt, dass die int passieren Sie ist immer größer als 1:

    struct myint
{
    int data; 
    myint(int i) : data(i) { assert(data > 1); }
};

    Benutzen es jetzt in Ihrer Klasse:

    class B : public A{
 public:
  B(myint dim) //this can still take int, due to implicit conversion! 
   : A(dim.data) { }
}

    Beachten Sie, dass Sie noch konstruieren B vorbei int werden, denn es wird implizit konvertieren in myint und während die Umwandlung stattfindet (implizit), es wird die Prüfung des behaupten, und wenn das gelingt, nur dann würden Sie in der Lage sein, um pass dim.data an der Basis-Klasse A. Wenn die behaupten fehl, das Programm abzubrechen, bevor Sie in der Basisklasse Konstruktor (ohne initialisieren alles, was in der abgeleiteten Klasse auch).

    Könnte man auch verallgemeinern:

    //Summary : gint<N> makes sure that data > N
template<int N>
struct gint  //call it greater int
{
    int data; 
    gint(int i) : data(i) { assert(data > N); } //Use N here!
};

    Benutzen es jetzt in Ihrer Klasse:

    class B : public A{
 public:
  B(gint<1> dim) //the template argument 1 makes sure that dim.data > 1
   : A(dim.data) { }
}

    Benötigen Sie eine andere Klasse, zum Beispiel:

    class Xyz : public A{
 public:
  B(gint<10> dim)  //gint<10> makes sure that dim.data > 10
   : A(dim.data) { }
}

    Cool, nicht?

    Ich habe Unternehmen gesehen, wo es die Politik immer erklären, einziges argument Konstruktoren als explicit und ich glaube, es ist für einen guten Grund. Trotzdem glaube ich nicht, dass die Lösung des Problems ist ganz cool.
    Ja, Sie haben vielleicht gute Gründe. Aber es ist nicht immer gut. std::string hat non-explicit einziges argument-Konstruktor, und ich denke, es ist nicht explizit für einen guten Grund.
    Es ist cool, Lösung. In der Sowjetunion nannten wir solche Lösungen 'Kostyl' (es bedeutet "krummer Nagel" acording google translate)

    InformationsquelleAutor Nawaz

  2. 0

    Wenn Sie möchten, machen Sie die zweite option funktioniert, müssen Sie einen leeren Konstruktor zu A. Aber dies wird nicht helfen, Sie zu viel, weil die A - Objekt erstellt, bevor Sie den Konstruktor für B, so, ob Sie haben einen leeren Konstruktor oder eine consturctor, die nimmt ein Objekt des Typs int, werden Sie immer konstruieren ein Objekt vom Typ A.

    Wenn Ein ist so einfach, wie Sie es zeigen in dieser Probe, die ich glaube, es ist nicht eine große Sache für constuct es sogar für ungültig Dimmt. Wenn es komplexer ist, würde ich vorschlagen, Sie erstellen eine ampty consturctor für Ein, initialisiert als kleinen Teil Ein, wie möglich und dann eine init Methode zu tun, die komplexere Sachen.

    Und stellen Sie den leeren Konstruktor(was nicht call init()) geschützt, damit es Verwendung nur in B(int);

    InformationsquelleAutor Ivaylo Strandjev

Schreibe einen Kommentar