.rst .pdf

Contents

Esempi: Appendice 2

A2.0 Classificazione di forme geometriche

• main_00.h

/*
c++ -o main_00 main_00.cpp
*/

#include <iostream>
#include "forme.h"

using namespace std ;

int main (int argc, char ** argv)
{
  forma forma_base ;
  cout << "area: " << forma_base.area () << endl ;

  quadrato forma_quadrata (3.) ;
  cout << "area: " << forma_quadrata.area () << endl ;
  cout << "lato: " << forma_quadrata.lato () << endl ;
  forma_quadrata.cambia_lato (4.) ;
  cout << "area: " << forma_quadrata.area () << endl ;

   
  rettangolo forma_rettangolare (2., 3.) ;
  cout << "area: " << forma_rettangolare.area () << endl ;
   
  return 0 ;
}

• forme.h

#ifndef forme_h
#define forme_h


class forma
{ 
  public:
    
    forma (double area = -1.) : m_area (area) {} ;
    ~forma () {} ;
    double area () const { return m_area ; } ;

  protected:  

    double m_area ;

} ;


// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----


class quadrato : public forma 
{
  public:

    quadrato (double lato = 1.) :
      m_lato (lato),
      forma (lato * lato) {}

    double lato () const { return m_lato ; }
    void cambia_lato (double lato) 
      {
        m_lato = lato ;
        m_area = m_lato * m_lato ;
        return ;
      } ;

    ~quadrato () {} ;

  private:  

    double m_lato ;

} ;


// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----


class rettangolo : public forma 
{
  public:

    rettangolo (double lato_o = 1., double lato_v = 1.) :
      m_lato_o (lato_o),
      m_lato_v (lato_v),
      forma (lato_o * lato_v) {}

    double lato_o () const { return m_lato_o ; }
    double lato_v () const { return m_lato_v ; }


    void cambia_lato_o (double lato) 
      {
        m_lato_o = lato ;
        m_area = m_lato_o * m_lato_v ;
        return ;
      } 

    void cambia_lato_v (double lato) 
      {
        m_lato_v = lato ;
        m_area = m_lato_o * m_lato_v ;
        return ;
      }


    ~rettangolo () {} ;

  private:  

    double m_lato_o ;
    double m_lato_v ;

} ;


#endif

A2.1 Compatibilità fra tipi in una catena ereditaria

• main_01.cpp

/*
c++ -o main_01 main_01.cpp
*/

#include <iostream>
#include "forme.h"

using namespace std ;

int main (int argc, char ** argv)
{
  quadrato forma_quadrata (3.) ;
  forma * puntatore = & forma_quadrata ;
   
  return 0 ;
}

A2.2 ereditarietà e polimorfismo con forme geometriche

• main_02.cpp

/*
c++ -o main_02 main_02.cpp
*/

#include <iostream>
#include "forme_polim.h"

using namespace std ;

int main (int argc, char ** argv)
{
  quadrato forma_quadrata (3.) ;
  forma * puntatore = & forma_quadrata ;
   
  cout << "area " << puntatore->calcola_area () << endl ;

  return 0 ;
}

• forme_polim.cpp

#ifndef forme_h
#define forme_h


class forma
{ 
  public:
    
    forma (double area = -1.) : m_area (area) {} 
    ~forma () {} 
    double area () const { return m_area ; } 
    virtual double calcola_area () { return -1. ; } 

  protected:  

    double m_area ;

} ;


// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----


class quadrato : public forma 
{
  public:

    quadrato (double lato = 1.) :
      m_lato (lato),
      forma (lato * lato) {}

    double lato () const { return m_lato ; }
    void cambia_lato (double lato) 
      {
        m_lato = lato ;
        calcola_area () ;
        return ;
      } ;

    virtual double calcola_area () 
      { 
        m_area = m_lato * m_lato ; 
        return m_area ; 
      }

    ~quadrato () {} ;

  private:  

    double m_lato ;

} ;


// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----


class rettangolo : public forma 
{
  public:

    rettangolo (double lato_o = 1., double lato_v = 1.) :
      m_lato_o (lato_o),
      m_lato_v (lato_v),
      forma (lato_o * lato_v) {}

    double lato_o () const { return m_lato_o ; }
    double lato_v () const { return m_lato_v ; }


    void cambia_lato_o (double lato) 
      {
        m_lato_o = lato ;
        calcola_area () ;
        return ;
      } 

    void cambia_lato_v (double lato) 
      {
        m_lato_v = lato ;
        calcola_area () ;
        return ;
      }

    virtual double calcola_area () 
      { 
        m_area = m_lato_o * m_lato_v ; 
        return m_area ; 
      }


    ~rettangolo () {} ;

  private:  

    double m_lato_o ;
    double m_lato_v ;

} ;


#endif

A2.3 ereditarietà polimorfica e contenitori STL

• main_03.cpp

/*
c++ -o main_03 main_03.cpp
*/

#include <iostream>
#include <vector>
#include <map>
#include "forme_polim.h"

using namespace std ;

int main (int argc, char ** argv)
{
  vector<forma *> v_forme ; 
  map<string, forma *> m_forme ; 
  
  forma forma_base ;
  v_forme.push_back (& forma_base) ; 
  m_forme["base"] = & forma_base ; 

  quadrato forma_quadrata (3.) ;
  v_forme.push_back (& forma_quadrata) ; 
  m_forme["quadrato"] = & forma_quadrata ; 

  rettangolo forma_rettangolare (3., 2.) ;
  v_forme.push_back (& forma_rettangolare) ; 
  m_forme["rettangolo"] = & forma_rettangolare ; 

  for (int i = 0 ; i < v_forme.size () ; ++i)
    cout << v_forme.at (i)->calcola_area () << endl ;

  cout << endl ;

  for (map<string, forma *>::const_iterator it = m_forme.begin () ;
       it != m_forme.end () ;
       ++it)
    cout << it->first << " ha area " << it->second->calcola_area () << endl ;

  return 0 ;
}

previous

Approfondimento A2: programmazione ad oggetti: l’ereditarietà public

next

Esercizi per l’appendice 2