«

Is there a way (except overloading) to limit function input to accept
__int64 but to get a compiler (preferable) or runtime (less preferable)
error if it is called with int?

for example:

void myfunction(__int64 param) // Accepts only __int64 as input and no
smaller
{
}

myfunction((__int64)1); // Call OK
myfunction((int)1); // Call fails or better - compiler reports error

On 10/24/11 11:28 AM, A wrote:
> Is there a way (except overloading) to limit function input to accept
> __int64 but to get a compiler (preferable) or runtime (less preferable)
> error if it is called with int?
>
> for example:
>
> void myfunction(__int64 param) // Accepts only __int64 as input and no
> smaller
> {
> }
>
> myfunction((__int64)1); // Call OK
> myfunction((int)1); // Call fails or better - compiler reports error

You can use a function template to force a link error:

#include <stdint.h>

template <typename T> void f( T n );

template <> void f( int64_t n ) // Specialise for acceptable types
{
}

Or give the function template a body to force a compiler warning:

template <typename T> void f( T n )
{
T tmp = n/0;
}

--
Ian Collins

"A" wrote:

> Is there a way (except overloading) to limit function input to accept
> __int64 but to get a compiler (preferable) or runtime (less preferable)
> error if it is called with int?

Assuming that __int64 is not the same type as int.

with overloading (what's wrong with overloading?):
void f(long){}
void f(int)=delete;

with sfinae:
template<class T,class=typename std::enable_if<std::is_same<T,long>::value>::type> void f(T){}

Thank you for your answers so far. I was hoping though for something without
templates. I did found though BOOST_STRONG_TYPEDEF which pretty much does
this.

On Oct 24, 12:28*am, "A" <a...@a.a> wrote:
> Is there a way (except overloading) to limit function input to accept
> __int64 but to get a compiler (preferable) or runtime (less preferable)
> error if it is called with int?

Out of curiosity... Why? int "is an" __int64 any way you look at this.
Why would it matter?

Goran.

On 24.10.2011 00:28, A wrote:
> Is there a way (except overloading) to limit function input to accept
> __int64 but to get a compiler (preferable) or runtime (less preferable)
> error if it is called with int?

> for example:
>
> void myfunction(__int64 param) // Accepts only __int64 as input and no
> smaller
void myfunction(const __int64& param);


Marcel

On 10/24/11 08:18 PM, Marcel Müller wrote:
> On 24.10.2011 00:28, A wrote:
>> Is there a way (except overloading) to limit function input to accept
>> __int64 but to get a compiler (preferable) or runtime (less preferable)
>> error if it is called with int?
>
>> for example:
>>
>> void myfunction(__int64 param) // Accepts only __int64 as input and no
>> smaller
> void myfunction(const __int64& param);

Won't the normal promotion rules still apply?

myfunction( 2 );

Compiles happily as does

int n = 0;
myfunction( n );

--
Ian Collins

On 10/24/11 08:53 PM, Ian Collins wrote:
> On 10/24/11 08:18 PM, Marcel Müller wrote:
>> On 24.10.2011 00:28, A wrote:
>>> Is there a way (except overloading) to limit function input to accept
>>> __int64 but to get a compiler (preferable) or runtime (less preferable)
>>> error if it is called with int?
>>
>>> for example:
>>>
>>> void myfunction(__int64 param) // Accepts only __int64 as input and no
>>> smaller
>> void myfunction(const __int64& param);
>
> Won't the normal promotion rules still apply?
>
> myfunction( 2 );
>
> Compiles happily as does
>
> int n = 0;
> myfunction( n );

Hit send too soon, I was going to add that

void myfunction( int64_t& param );

was probably what you intended to type.

--
Ian Collins

Ian Collins <ian-> wrote:
> Or give the function template a body to force a compiler warning:
>
> template <typename T> void f( T n )
> {
> T tmp = n/0;
> }

I don't think that's a very good idea.

In article <4ea51cef$0$2800$>,
Juha Nieminen <> wrote:
>Ian Collins <ian-> wrote:
>> Or give the function template a body to force a compiler warning:
>>
>> template <typename T> void f( T n )
>> {
>> T tmp = n/0;
>> }
>
> I don't think that's a very good idea.

A compile time assertion would be a bit safer.