深度探究C++中的函数重载的用法

// function_overloading.cpp
// compile with: /EHsc
#include <iostream>
#include <math.h>

// Prototype three print functions.
int print( char *s );         // Print a string.
int print( double dvalue );      // Print a double.
int print( double dvalue, int prec ); // Print a double with a
// given precision.
using namespace std;
int main( int argc, char *argv[] )
{
const double d = 893094.2987;
if( argc < 2 )
  {
// These calls to print invoke print( char *s ).
print( "This program requires one argument." );
print( "The argument specifies the number of" );
print( "digits precision for the second number" );
print( "printed." );
exit(0);
  }

// Invoke print( double dvalue ).
print( d );

// Invoke print( double dvalue, int prec ).
print( d, atoi( argv[1] ) );
}

// Print a string.
int print( char *s )
{
cout << s << endl;
return cout.good();
}

// Print a double in default precision.
int print( double dvalue )
{
cout << dvalue << endl;
return cout.good();
}

// Print a double in specified precision.
// Positive numbers for precision indicate how many digits
// precision after the decimal point to show. Negative
// numbers for precision indicate where to round the number
// to the left of the decimal point.
int print( double dvalue, int prec )
{
// Use table-lookup for rounding/truncation.
static const double rgPow10[] = { 
10E-7, 10E-6, 10E-5, 10E-4, 10E-3, 10E-2, 10E-1, 10E0,
10E1, 10E2, 10E3, 10E4, 10E5, 10E6
  };
const int iPowZero = 6;
// If precision out of range, just print the number.
if( prec < -6 || prec > 7 )
return print( dvalue );
// Scale, truncate, then rescale.
dvalue = floor( dvalue / rgPow10[iPowZero - prec] ) *
rgPow10[iPowZero - prec];
cout << dvalue << endl;
return cout.good();
}

Fraction &Add( Fraction &f, long l );    // Variant 1
Fraction &Add( long l, Fraction &f );    // Variant 2
Fraction &Add( Fraction &f, Fraction &f ); // Variant 3

Fraction F1, F2;

F1 = Add( F2, 23 );

F1 = Add( 3, 6 );

// argument_type_differences.cpp
// compile with: /EHsc /W3
// C4521 expected
#include <iostream>

using namespace std;
class Over {
public:
  Over() { cout << "Over default constructor\n"; }
  Over( Over &o ) { cout << "Over&\n"; }
  Over( const Over &co ) { cout << "const Over&\n"; }
  Over( volatile Over &vo ) { cout << "volatile Over&\n"; }
};

int main() {
  Over o1;      // Calls default constructor.
  Over o2( o1 );   // Calls Over( Over& ).
  const Over o3;   // Calls default constructor.
  Over o4( o3 );   // Calls Over( const Over& ).
  volatile Over o5;  // Calls default constructor.
  Over o6( o5 );   // Calls Over( volatile Over& ).
}

Over default constructor
Over&
Over default constructor
const Over&
Over default constructor
volatile Over&

// argument_matching1.cpp
class UDC
{
public:
  operator int()
  {
   return 0;
  }
  operator long();
};

void Print( int i )
{
};

UDC udc;

int main()
{
  Print( udc );
}

void LogToFile( long l );
...
UDC udc;
LogToFile( udc );

// argument_matching2.cpp
// C2668 expected
class UDC1
{
public:
  UDC1( int ); // User-defined conversion from int.
};

class UDC2
{
public:
  UDC2( long ); // User-defined conversion from long.
};

void Func( UDC1 );
void Func( UDC2 );

int main()
{
  Func( 1 );
}

// Expression encountered in code
obj.name

// How the compiler treats it
(&obj)->name

typedef char * PSTR;

void Print( char *szToPrint );
void Print( PSTR szToPrint );

void Print( char *szToPrint );
void Print( char szToPrint[] );

void Print( char szToPrint[] );
void Print( char szToPrint[][7] );
void Print( char szToPrint[][9][42] );

// declaration_matching1.cpp
// compile with: /EHsc
#include <iostream>

using namespace std;
void func( int i )
{
  cout << "Called file-scoped func : " << i << endl;
}

void func( char *sz )
{
  cout << "Called locally declared func : " << sz << endl;
}

int main()
{
  // Declare func local to main.
  extern void func( char *sz );

  func( 3 );  // C2664 Error. func( int ) is hidden.
  func( "s" );
}

// declaration_matching2.cpp
class Account
{
public:
  Account()
  {
  }
  double Deposit( double dAmount, char *szPassword );

private:
  double Deposit( double dAmount )
  {
   return 0.0;
  }
  int Validate( char *szPassword )
  {
   return 0;
  }

};

int main()
{
  // Allocate a new object of type Account.
  Account *pAcct = new Account;

  // Deposit $57.22. Error: calls a private function.
  // pAcct->Deposit( 57.22 );

  // Deposit $57.22 and supply a password. OK: calls a
  // public function.
  pAcct->Deposit( 52.77, "pswd" );
}

double Account::Deposit( double dAmount, char *szPassword )
{
  if ( Validate( szPassword ) )
   return Deposit( dAmount );
  else
   return 0.0;
}