Comment puis-je éviter les conversions implicites sur la non-construction de fonctions?

Vous ne pouvez pas directement, car un char est automatiquement promu int.

Vous pouvez recourir à une astuce cependant: créer une fonction qui prend un char comme paramètre, et ne pas la mettre en œuvre. Elle compile, mais vous aurez une erreur de l'éditeur de liens:

void function(int i) 
{
}
void function(char i);
//or, in C++11
void function(char i) = delete;

L'appel de la fonction avec un char paramètre briser la construction.

Voir http://ideone.com/2SRdM

Terminologie: non-construcing fonctions? Voulez-vous dire une fonction qui n'est pas un constructeur?

Voici une solution qui provoque une erreur à la compilation si function est appelée avec rien mais un int

template <typename T>
struct is_int { static const bool value = false; };

template <>
struct is_int<int> { static const bool value = true; };


template <typename T>
void function(T i) {
  static_assert(is_int<T>::value, "argument is not int");
  return;
}

int main() {
  int i = 5;
  char c = 'a';

  function(i);
  //function(c);

  return 0;
}

Il fonctionne en permettant à n'importe quel type de l'argument à une fonction, mais à l'aide de is_int comme au niveau du type de prédicat. Le générique de la mise en œuvre de is_int a une valeur fausse, mais la spécialisation explicite pour le type int a la valeur true pour que la statique de faire valoir les garanties que l'argument est exactement le type int sinon, il y a une erreur de compilation.

Pour le C++14 (et je crois que C++11), vous pouvez désactiver la copie constructeurs par la surcharge rvalue-références ainsi:

Exemple:
Disons que vous avez une base de Binding<C> classe, où C est soit la base Constraint classe ou d'une classe héritée. Dites que vous stockez Binding<C> en valeur dans un vecteur, et que vous passez une référence à la liaison et vous souhaitez vous assurer que vous ne causent pas un implicite copie.

Vous pouvez le faire en supprimant func(Binding<C>&& x) (par PiotrNycz l'exemple de rvalue-référence des cas spécifiques.

Extrait de:

template<typename T>
void overload_info(const T& x) {
  cout << "overload: " << "const " << name_trait<T>::name() << "&" << endl;
}

template<typename T>
void overload_info(T&& x) {
  cout << "overload: " << name_trait<T>::name() << "&&" << endl;
}

template<typename T>
void disable_implicit_copy(T&& x) = delete;

template<typename T>
void disable_implicit_copy(const T& x) {
  cout << "[valid] ";
  overload_info<T>(x);
}

...

int main() {
  Constraint c;
  LinearConstraint lc(1);

  Binding<Constraint> bc(&c, {});
  Binding<LinearConstraint> blc(&lc, {});

  CALL(overload_info<Binding<Constraint>>(bc));
  CALL(overload_info<Binding<LinearConstraint>>(blc));

  CALL(overload_info<Binding<Constraint>>(blc));

  CALL(disable_implicit_copy<Binding<Constraint>>(bc));
  ////Causes desired error
  //CALL(disable_implicit_copy<Binding<Constraint>>(blc));
}

De sortie:

>>> overload_info(bc)
overload: T&&

>>> overload_info<Binding<Constraint>>(bc)
overload: const Binding<Constraint>&

>>> overload_info<Binding<LinearConstraint>>(blc)
overload: const Binding<LinearConstraint>&

>>> overload_info<Binding<Constraint>>(blc)
implicit copy: Binding<LinearConstraint>  ->  Binding<Constraint>
overload: Binding<Constraint>&&

>>> disable_implicit_copy<Binding<Constraint>>(bc)
[valid] overload: const Binding<Constraint>&

D'erreur (avec clang-3.9 dans bazel, lorsque la ligne incriminée est sans commentaire):

cpp_quick/prevent_implicit_conversion.cc:116:8: error: call to deleted function 'disable_implicit_copy'
  CALL(disable_implicit_copy<Binding<Constraint>>(blc));
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

L'Intégralité Du Code Source: prevent_implicit_conversion.cc

J'ai d'abord essayé PiotrNycz de l'approche (pour C++03, je suis obligé de l'utiliser pour un projet), puis j'ai essayé de trouver une approche plus générale et est venu avec cette ForcedType<T> classe de modèle.

template <typename T>
struct ForcedType {
    ForcedType(T v): m_v(v) {}
    operator T&() { return m_v; }
    operator const T&() const { return m_v; }

private:
    template <typename T2>
    ForcedType(T2);

    T m_v;
};

template <typename T>
struct ForcedType<const T&> {
    ForcedType(const T& v): m_v(v) {}
    operator const T&() const { return m_v; }

private:
    template <typename T2>
    ForcedType(const T2&);

    const T& m_v;
};

template <typename T>
struct ForcedType<T&> {
    ForcedType(T& v): m_v(v) {}
    operator T&() { return m_v; }
    operator const T&() const { return m_v; }

private:
    template <typename T2>
    ForcedType(T2&);

    T& m_v;
};

Si je ne me trompe pas, ces trois spécialisations devraient couvrir tous les cas d'utilisation courants. Je ne suis pas sûr si une spécialisation pour les rvalue-référence (sur le C++11 ans) est réellement nécessaire ou la valeur de l'un suffit.

On pourrait l'utiliser comme ceci, dans le cas d'une fonction de 3 paramètres dont le 3e paramètre ne permet pas de conversion implicite:

function(ParamType1 param1, ParamType2 param2, ForcedType<ParamType3> param3);