remplacer constructeur de c++

J'ai Une classe abstraite

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

et de classe B

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

et j'ai besoin de faire du constructeur pour la classe B, qui fonctionne uniquement lorsque le dim > 1 et lancer des affirmations du contraire.

dans ce cas

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

cela fonctionne, mais ce n'est pas la bonne solution je pense, parce que l'instance de la classe a a été créé et supprimé.

Que je fais init-méthode pour la classe A:

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

et de modifier le constructeur de la classe B:

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

mais ça ne fonctionne pas. Est-il possible de solutions pour mon problème?

  • classe A n'est pas abstrait...
  • d'une certaine manière, j'ai l'impression que le fait de compter sur "normal" dans votre ctor est pas la bonne approche.
InformationsquelleAutor user1761982 | 2013-01-05
  1. 5

    Je pense que vous pourriez écrire un petit myint classe qui permet de s'assurer que le int vous passer est toujours plus grande que 1:

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

    Maintenant l'utiliser dans votre classe:

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

    Notez que vous pouvez toujours construire B passant int, car elle permettra de convertir implicitement dans myint et tandis que la conversion a lieu (de manière implicite), il permettra de tester l' affirmer, et si cela réussit, alors seulement vous serez en mesure de passer dim.data à la classe de base A. Si le affirmer échoue, votre programme s'arrête avant d'entrer dans le constructeur de classe de base (sans l'initialisation de quoi que ce soit dans la classe dérivée aussi).

    On pourrait même généraliser comme:

    //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!
};

    Maintenant l'utiliser dans votre classe:

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

    Si vous avez besoin d'une autre classe, par exemple:

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

    Cool, n'est-ce pas?

    • J'ai vu des sociétés où il y a une politique de toujours déclarer seul argument des constructeurs comme explicit et je crois que c'est pour une bonne raison. Cependant, je crois que votre solution pour le problème est assez cool.
    • Oui, ils peuvent avoir de bonnes raisons. Mais il n'est pas toujours bon. std::string a non-explicite seul argument du constructeur, et je pense que c'est non-explicite pour une bonne raison.
    • C'est cool solution. En russie soviétique, nous avons appelé ces solutions Kostyl' (c'est à dire "crooked clou" selon google translate)
    InformationsquelleAutor Nawaz
  2. 0

    Si vous voulez vous faire deuxième option fonctionne, vous devez ajouter un constructeur vide à A. Cependant, cela ne vous aidera pas trop car l' A objet est créé avant d'entrer dans le constructeur de B, donc si vous avez un constructeur vide ou un consturctor qui prend un objet de type int, vous aurez toujours de construire un objet de type A.

    Si Un est aussi simple que de vous montrer dans cet exemple je crois que c'est pas un gros problème pour construire ce, même pour les non valide s'estompe. Si elle est plus complexe, je vous suggère de créer un ampty consturctor pour Un qui initialise comme petite partie d'Un possible et un init méthode pour faire des trucs plus complexe.

    • Et de faire le constructeur vide(ce qui ne veut pas appeler init()) protégé afin de permettre son utilisation que dans B(int);
    InformationsquelleAutor Ivaylo Strandjev