Lesson of 22 February 2011

Example of ``struct`` with methods

File example1.cc

// to compile on unix/OSX use
// g++ example1.cc (for generation of testDecoration.o)
// ./a.out (to run)
//

#include <iostream>
#include <algorithm>

/*
  A stupid example of variable size vector
 */

typedef struct variableVector {
  int    size ;
  double * values ;
  
  // define a constructor
  variableVector() {
    std::cout << "create a variableVector\n" ;
    size   = 0 ;
    values = NULL ;
  }

  // define a constructor
  variableVector( int sz ) {
    std::cout << "create a variableVector of size " << sz << "\n" ;
    size   = sz ;
    values = new double[sz] ;
  }
  
  // define a destructor
  ~variableVector() {
    std::cout << "destroy a variableVector\n" ;
    if ( values != NULL ) delete [] values ;
  }
  
  // ri-define default assignment operator
  variableVector const &
  operator = ( variableVector const & a ) {
    std::cout << "use variableVector const & operator =\n" ;
    size = a . size ;
    if ( values != NULL ) delete [] values ;
    values = new double[ size ] ;
    for ( int i = 0 ; i < size ; ++i ) values[i] = a . values[i] ;
  }

  // declaration of a method which will add a to the struct
  void addTo( struct variableVector const & a ) ; 

} variableVector ;

// instance of addTo struct variableVector b, a ; b . addTo( a ) ;
void
variableVector::addTo( variableVector const & a ) {
  int minSize = std::min( size, a . size ) ;
  for ( int i = 0 ; i < minSize ; ++i ) values[i] += a . values[i] ;
}

// prototype (declaration) of a C like function to add vector a to vector b
void
addTo( variableVector const & a,
       variableVector       & res ) {
  int minSize = std::min( res . size, a . size ) ;
  for ( int i = 0 ; i < minSize ; ++i ) res . values[i] += a . values[i] ;
}

// prototype (declaration) of a C like
void
allocate( variableVector & res, int size ) {
  res . size = size ;
  if ( res . values != NULL ) delete [] res . values ;
  res . values = new double[ size ] ;
}

// allocate resource for res
void
deallocate( variableVector & res ) {
  res . size   = 0;
  delete [] res . values ;
  res . values = NULL ;
}

// initialize vector res
void
initialize( variableVector & res ) {
  res . size   = 0;
  res . values = NULL ;
}

// perform deep copy of a to res
void
deepCopy( variableVector const & a, variableVector & res ) {
  allocate( res, a.size ) ;
  for ( int i = 0 ; i < a.size ; ++i ) res . values[i] = a . values[i] ;
}

void
copy( variableVector const & a, variableVector & res ) {
  res . size   = a . size ;
  res . values = a . values ; // loss pointer res . values
}

int
main() {
  variableVector a, b(100), c(120) ;
  initialize(a) ;

  allocate( a, 100 ) ;
  
  //copy( a, b ) ;
  std::cout << "passa\n" ;
  a = b ;
  std::cout << "passa\n" ;
  
  a . size = 0 ; // corrupt the "class" a

  return 0 ;
}

A simple class

File example2.cc

// to compile on unix/OSX use
// g++ example2.cc (for generation of testDecoration.o)
// ./a.out (to run)
//

#include <iostream>
#include <algorithm>

/*
  A stupid example of variable size vector
 */

class variableVector {
  // private part of the class
  int    size ;
  double * values ;
  
  void allocate( int sz ) {
    if ( values != NULL ) delete [] values ;
    values = new double[ sz ] ;  
  }

  void deallocate() {
    if ( values != NULL ) delete [] values ;
    values = NULL ;  
  }

public:

  // define a constructor
  variableVector() {
    std::cout << "create a variableVector\n" ;
    size   = 0 ;
    values = NULL ;
  }

  // define a constructor
  variableVector( int sz ) {
    std::cout << "create a variableVector of size " << sz << "\n" ;
    allocate(sz) ;
  }
  
  int getSize() const { return size ; }
  
  // destructor
  ~variableVector() {
    std::cout << "destroy a variableVector\n" ;
    deallocate() ;
  }
  
  variableVector const &
  operator = ( variableVector const & a ) {
    std::cout << "use variableVector const & operator =\n" ;
    allocate( a.size ) ;
    for ( int i = 0 ; i < size ; ++i ) values[i] = a . values[i] ;
  }

  // declaration of a method which will add a to the struct
  void addTo( struct variableVector const & a ) ; 

} ;

// instance of addTo struct variableVector b, a ; b . addTo( a ) ;
void
variableVector::addTo( variableVector const & a ) {
  int minSize = std::min( size, a . size ) ;
  for ( int i = 0 ; i < minSize ; ++i ) values[i] += a . values[i] ;
}

int
main() {
  variableVector a, b(100), c(120) ;
  
  //copy( a, b ) ;
  a = b ;
  a . getSize() ;

  return 0 ;
}

A simple example of template metaprogramming

File example3.cc

// to compile on unix/OSX use
// g++ example3.cc (for generation of testDecoration.o)
// ./a.out (to run)
//


#include <iostream>
#include <algorithm>

/*
  Example of template metaprogram
 */

template <unsigned N>
class Vector {
  int values[N] ;
} ;

template <unsigned N>
class Factorial {
public:
  static unsigned const RES = N*Factorial<N-1>::RES ;
} ;

template <>
class Factorial<1> {
public:
  static unsigned const RES = 1 ;
} ;

int
main() {
  Vector<10> a, b, c ;
  Factorial<1>  f1 ;
  Factorial<2>  f2 ;
  Factorial<6>  f6 ;
  Factorial<10> f10 ;

  std::cout << f1.RES  << '\n' ; // access to class variable RES
  std::cout << f2.RES  << '\n' ; // access to class variable RES
  std::cout << f6.RES  << '\n' ; // access to class variable RES
  std::cout << f10.RES << '\n' ; // access to class variable RES

  return 0 ;
}

---