Lesson of 24 June 2008

An example of overloading

File overloading.cc

:open:

/*
// An example of overloading
//
*/

#include <iostream>

using namespace std ;

// define the function factorial with integer argument
int
factorial( int a ) {
  cout << "using factorial(int) with a = " << a << "\n" ;
  if ( a > 1 ) return a*factorial(a-1) ;
  else         return 1 ;
}

// define the function factorial with unsigned long integer argument
unsigned long
factorial( unsigned long a ) {
  cout << "using factorial(unsigned long) with a = " << a << "\n" ;
  if ( a > 1 ) return a*factorial(a-1) ;
  else         return 1 ;
}

int
main() {
  unsigned long ula = 10 ;
  int           ia  = 10 ;
  cout << factorial(ia) << "\n" ;
  cout << factorial(ula) << "\n" ;
  long b = factorial(ia) ;
  return 0 ;
}

An example of Inheritance

File inherith.cc

:open:

/*
// An example of inheritance
//
*/

#include <iostream>

using namespace std ;

// define a base class
class base_class {
  int value ; // declare private variable
public:

  base_class()
  : value(0) // calling the costructor for value
  { cout << "base_class constructor\n" ; }
  /* this is similar to
     base_class(){ value = 0 ; }
     the difference is on the order of the operatio.
     in this latter case the default costrutor for
     value  is performed and next is assigned to 0.
     using the proposed costruct the variable value
     is initialized to 0 directly. Thus is a better 
     performing design 
  */

  // a public method
  void printName(ostream & s)
  { s << "I am base class\n" ; }

  // accessor method
  int getValue() const { return value ; }
} ;

// define extend_class inherithing from base_class
class extend_class : public base_class {
public:
  extend_class()
  : base_class() // call the base_class constructor
  { cout << "extend_class constructor\n" ; }
 
  // redefine the method printName
  void printName(ostream & s)
  { s << "I am extend_class class\n" ; }
} ;

int
main() {
  base_class   bc ; // instance bc with the default constructor
  extend_class ec ; // instance ec with the default constructor
  bc . printName( cout ) ;
  ec . printName( cout ) ;
  return 0 ;
}

An example of Inheritance (bis)

File inherith2.cc

:open:

/*
// An example of inheritance
//
*/

#include <iostream>

using namespace std ;

typedef double valueType ;
typedef int    indexType ;

class point2d {
protected:
  valueType x, y ;
public:

  point2d() : x(0), y(0) // calling the costructor for value
  { cout << "point2d constructor\n" ; }

  point2d(valueType xx, valueType yy) : x(xx), y(yy) // calling the costructor for value
  { cout << "point2d constructor N.2\n" ; }

  ~point2d()
  { cout << "point2d destructor\n" ; }

  point2d const &
  operator = (point2d const & a) { 
    cout << "assign operator\n" ;
    x = a.x ;
    y = a.y ;
    return *this ;
  }

  valueType getX() const { return x ; }
  valueType getY() const { return y ; }
  void set( valueType x, valueType y ) {
    this -> x = x ;
    this -> y = y ;
  }

} ;

class point3d : public point2d {
  valueType z ;
public:

  point3d() : point2d(0,0), z(0) // calling the costructor for value
  { cout << "point3d constructor\n" ; }

  point3d(valueType xx, valueType yy, valueType zz)
  : point2d(xx,yy), z(zz) // calling the costructor for value
  { cout << "point3d constructor N.2\n" ; }

  ~point3d()
  { cout << "point3d destructor\n" ; }

  point3d const &
  operator = (point3d const & a) { 
    cout << "assign operator\n" ;
    x = a.x ;
    y = a.y ;
    z = a.z ;
    return *this ;
  }

  valueType getZ() const { return z ; }

  void set( valueType x, valueType y, valueType z ) {
    point2d::set(x,y) ;
    this -> z = z ;
  }
} ;


// define external operator for addition
point2d
operator + ( point2d const & a, point2d const & b)
{ cout << "perform + operator\n" ;
  return point2d( a.getX()+b.getX(), a.getY() + b.getY()) ; }
/*

 */

int
main() {
  cout << "before point2d a, b ;\n" ;
  point2d a, b, c ;
  cout << "after point2d a, b ;\n" ;
  c = a + b ;
  // this is eqauivalent to 
  
  c . operator = ( operator + (a,b) ) ;

  cout << "before to exit;\n" ;
  // the same operatio without temporary class production
  a . set( a.getX() + b.getX(), a.getY() + b.getY() ) ;
  return 0 ;
}

The lesson in a zip file

The zip file lesson3.zip

---