Éviter la conversion implicite dans le constructeur. Le mot clé "explicit" n'est pas utile ici.

Question

Je suis en mesure d'éviter la conversion implicite d'un constructeur à l'aide de la balise explicit mot-clé. Donc maintenant, les conversions comme A a1 = 10; peut être évitée.

Mais je peux toujours initialiser A a1 = A(20.2); . Comment puis-je désactiver la création d'objet de sorte qu'un objet ne puisse être créé que si nous passons un entier comme paramètre, par exemple. A a1 = A(10) ?

#include <iostream>

class A
{
public:
    explicit A(int a)
    {
        num = a;
    }

    int num;
};

int main()
{
    A a1 = A(10.0);
    std::cout << a1.num;
    return 0;
}

Answer 1

Puedes delete A::A(<anything not an int>); :

struct A
{
    explicit A(int a)
    : num(a)
    {}

    template<class T>
    A(T) = delete;

    int num;
};

int main()
{
    //A a1=A(10.0); // error: use of deleted function 'A::A(T) [with T = double]'
    A a2 = A(10); // OK
    (void) a2;
}

Démonstration : https://coliru.stacked-crooked.com/a/425afc19003697c9

Answer 2

La façon d'y parvenir est de fournir un autre constructeur qui correspondrait mieux, et ensuite delete alors vous obtiendrez une erreur. Pour votre classe, en ajoutant

template <typename T>
A(T) = delete;

Empêchera la classe d'être construite à partir de n'importe quel élément qui n'est pas un int

Answer 3

Vous pouvez contourner ce problème en utilisant une initialisation entre accolades. Par exemple :

struct A {
  A(int _a) : a(_a) {}
  int a;
};

A a{5}; // ok
A b{1.123}; // compile error

Preuve

Answer 4

Je veux juste ajouter que le A(double) = delete est un C++11 addition.

Si, pour une raison quelconque, vous ne pouvez pas utiliser cette construction relativement nouvelle, vous pouvez simplement la déclarer comme privée :

class A{
  public:
    A(int);
  private:
    A(double);
}

Answer 5

Pour éviter les conversions int->double partout, et pas seulement dans votre cas. Avec g++, vous pouvez utiliser -Wconversion -Werror . Notez qu'il sera autorisé dans votre cas particulier, car le compilateur comprend que 10.0 est littéral, mais il échouera à la compilation pour :

class A
{
public:
    explicit A(int a)
    {
        num = a;
    }

    int num;
};

int main()
{
    double x = 10;
    A a1 = A(x);
    static_cast<void>(a1);
    return 0;
}

Explorateur de compilateurs