.rst .pdf

Contents

Esempi: Lezione 2

2.0 Definizione della classe complesso

#ifndef complesso_h
#define complesso_h

class complesso
{
public: 
  complesso (double r, double i) ;
  complesso (const complesso & orig) ;
  ~complesso () ;

  double modulo () ;      
  double fase () ;    
  double parte_reale () const ;
  double parte_immaginaria () const ;

  void stampami () ; 

  complesso operator+ (const complesso & addendo) ;  
  complesso & operator= (const complesso & orig) ;  

private:
  double m_real ;
  double m_imag ;
} ;

complesso operator+ (const complesso & uno, const double & due) ;


#endif

2.1 Implementazione della classe complesso

#include <cmath>
#include <iostream>
#include "complesso.h"


complesso::complesso (double r, double i):
  m_real (r),
  m_imag (i)
  {}

complesso::complesso (const complesso & orig):
  m_real (orig.m_real),
  m_imag (orig.m_imag)
  {}

complesso::~complesso () {}

double 
complesso::modulo ()
  {
    return sqrt (m_real * m_real + m_imag * m_imag) ;
  }

double 
complesso::parte_reale () const
{
  return m_real ;
}

double 
complesso::parte_immaginaria () const
{
  return m_imag ;
}

void
complesso::stampami ()
{
  std::cout << this->m_real << " + " << this->m_imag << "i" << std::endl ;
  return ;
}

complesso
complesso::operator+ (const complesso & addendo)
{
 complesso somma (m_real, m_imag) ;
 somma.m_real = somma.m_real + addendo.m_real ;
 somma.m_imag = somma.m_imag + addendo.m_imag ;
 return somma ;
}

complesso & 
complesso::operator= (const complesso & orig)
{
  m_real = orig.m_real ;
  m_imag = orig.m_imag ;
  return *this ;
}  

complesso operator+ (const complesso & uno, const double & due)
  {
    double real = uno.parte_reale () + due ;
    double imag = uno.parte_immaginaria () ;
    complesso somma (real, imag) ;
    return somma ;
  }

2.2 Primo test della classe complesso

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

#include <iostream>
#include <cmath>
#include "complesso.h"

int main (int argc, char ** argv)
{
  // test del constructor
  complesso numero_complesso_1 (0., 0.) ;
  complesso numero_complesso_2 (3., 4.) ;

  std::cout << numero_complesso_1.modulo () << std::endl ;
  std::cout << numero_complesso_2.modulo () << std::endl ;

  // test del copy constructor
  complesso numero_complesso_3 (numero_complesso_2) ;

  // test dell'operator+
  complesso numero_complesso_4 = numero_complesso_3 + numero_complesso_2 ;
//  complesso numero_complesso_4 = numero_complesso_3.operator+ (numero_complesso_2) ;
  numero_complesso_4.stampami () ;

  // test dell'operator=
  complesso numero_complesso_5 = numero_complesso_4 + 5. ;
  numero_complesso_5.stampami () ;

  complesso numero_complesso_6 = numero_complesso_5 = numero_complesso_2 ;
  numero_complesso_5.stampami () ;
  numero_complesso_6.stampami () ;

  return 0 ;
}

2.3 Uso di const con tipi predefiniti

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

#include <iostream>

int main (int argc, char ** argv)
{
  const int C1 = 10 ;
  int const C1_1 = 10 ;
  const int * C2 ;
  int const * C2_2 ;
  int numero = 3 ;
  int * const C3 (& numero) ;
  int const * const C4 (& C1) ;

  return 0 ;
}

previous

Lezione 2: programmazione ad oggetti, le classi

next

Esercizi per la lezione 2