How do I avoid implicit conversions on non-constructing functions?

Question

How do I avoid implicit casting on non-constructing functions?
I have a function that takes an integer as a parameter,
but that function will also take characters, bools, and longs.
I believe it does this by implicitly casting them.
How can I avoid this so that the function only accepts parameters of a matching type, and will refuse to compile otherwise?
There is a keyword "explicit" but it does not work on non-constructing functions. :\
what do I do?

The following program compiles, although I'd like it not to:

#include <cstdlib>  //the function signature requires an int void function(int i);  int main(){      int i{5};     function(i); //<- this is acceptable      char c{'a'};     function(c); //<- I would NOT like this to compile      return EXIT_SUCCESS; }  void function(int i){return;} 

*please be sure to point out any misuse of terminology and assumptions

Answer 1

Define function template which matches all other types:

void function(int); // this will be selected for int only  template <class T> void function(T) = delete; // C++11  

This is because non-template functions with direct matching are always considered first. Then the function template with direct match are considered - so never function<int> will be used. But for anything else, like char, function<char> will be used - and this gives your compilation errrors:

void function(int) {}  template <class T> void function(T) = delete; // C++11    int main() {    function(1);    function(char(1)); // line 12 }  

ERRORS:

prog.cpp: In function 'int main()': prog.cpp:4:6: error: deleted function 'void function(T) [with T = char]' prog.cpp:12:20: error: used here 

This is C++03 way:

// because this ugly code will give you compilation error for all other types class DeleteOverload { private:     DeleteOverload(void*); };   template <class T> void function(T a, DeleteOverload = 0);  void function(int a) {} 

Answer 2

You can't directly, because a char automatically gets promoted to int.

You can resort to a trick though: create a function that takes a char as parameter and don't implement it. It will compile, but you'll get a linker error:

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

Calling the function with a char parameter will break the build.

See http://ideone.com/2SRdM

Terminology: non-construcing functions? Do you mean a function that is not a constructor?