overload resolution

[Wolfgang Jeltsch]

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]

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

[Filipe Sousa]

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)