«

Hello,

consider the following code:
#include <iostream.h>

template < typename T >
int f( T v ) {
return 0;
}

int f( int i ) {
return i;
}

int main() {
cout << f( 1 ) << '\n';

return 0;
}

Is this correct and guaranteed to output 1? Or is there a conflict between
the template f which can be instantiated to
int f< int >( int )
and the function f which is declared as
int f( int )?

Wolfgang

Wolfgang Jeltsch wrote:

> Hello,
>
> consider the following code:
> #include <iostream.h>
>
> template < typename T >
> int f( T v ) {
> return 0;
> }
>
> int f( int i ) {
> return i;
> }
>
> int main() {
> cout << f( 1 ) << '\n';
>
> return 0;
> }
>
> Is this correct and guaranteed to output 1? Or is there a conflict between
> the template f which can be instantiated to
> int f< int >( int )
> and the function f which is declared as
> int f( int )?
>
> Wolfgang

Additional question: How does overload resolution work if we take
constructors instead of ordinary functions:
template < typename T >
class C {
private:
T v;

public:
template < typename TT >
C( const C< TT > &source );
C( const C &source );
};

I think that for implicit copy operations the explicitely defined copy
constructor is used instead of a template instance with T equal to TT. But
what is done if I initialize explicitely or call constructors explicitely?
Is there a conflict if T and TT are equal?

Thanks in advance!

Wolfgang

Wolfgang Jeltsch wrote:

> Hello,
>
> consider the following code:
> #include <iostream.h>
>
> template < typename T >
> int f( T v ) {
> return 0;
> }
>
> int f( int i ) {
> return i;
> }
>
> int main() {
> cout << f( 1 ) << '\n';
>
> return 0;
> }
>
> Is this correct and guaranteed to output 1? Or is there a conflict between
> the template f which can be instantiated to
> int f< int >( int )
> and the function f which is declared as
> int f( int )?
>
> Wolfgang

the result is garanteed to be 1 because int f( int ) is more especific than
int f<int>(int)