ohm_cpp

File: /home/peppino/Area_Lavori/ese…orgenti/Oggetti/ohm_classe.cpp
Pagina 1 di 5
/**
* esempi_c++/sorgenti/ohm_classe.cpp
*
* Una classe semplice per applicare la legge di OHM
*
* @autore Giuseppe Talarico
19/01/2004
* @data
*/
//
//
//
//
posizionarsi nella cartella esempi_c++
compilare: c++ ./sorgenti/ohm_classe.cpp -o ./eseguibili/ohm -g
eseguire:
./eseguibili/ohm
testare:
lanciare Kdbg
using namespace std;
#include <iostream>
/*
La figura seguente mostra l' interfaccia della classe Ohm. Le
( set method ) sono quelle che puntano verso i "dati privati"
indicare che possono modificare i dati stessi.
Le funzioni di accesso ( get method ) sono quelle che puntano
per indicare che possono solo leggere i dati privati.
Visto che i dati vengono definiti "privati", solo le funzioni
della classe vi possono accedere.
funzioni di mutazione
o "incapsulati", per
dalla parte opposta
membro (funzioni di mutazione)
---------------|
Ohm
|
---------------Ohm() ----->|
|
Ohm( int unaresistenza , double unatensione)
----->| resistenza |
modifica_resistenza(int valore) ----->| tensione
|
modifica_tensione(double valore) ----->| corrente
|
calcola_corrente() ----->|
|
|
^
|
leggi_resistenza() <-----|
dati
|
leggi_tensione()
<-----|
privati
|
leggi_corrente()
<-----|
|
mostra_valori()
<-----|
|
|
|
---------------*/
//======================= Interfaccia della classe Ohm ==================================
class Ohm
{
private:
// variabili o campi istanza
int resistenza;
double tensione;
double corrente;
public:
// in ohm
// in Volt
// in Ampere
File: /home/peppino/Area_Lavori/ese…orgenti/Oggetti/ohm_classe.cpp
//---------------------- costruttore ---------------------------/**
Costuisce un oggetto Ohm
con resistenza= 1 ohm e tensione nulla
*/
Ohm();
//---------------------- costruttore ---------------------------/**
Costruisce un oggetto con valori iniziali non nulli
@param unaresistenza , unatensione
*/
Ohm( int unaresistenza , double unatensione);
//---------------------- metodo set ---------------------------------/**
Modifica il valore della resistenza
*/
@param
valore //in ohm
void modifica_resistenza(int valore);
//---------------------- metodo ---------------------------------/**
Modifica il valore della tensione
*/
@param
valore //in volt
void modifica_tensione(double valore);
//---------------------- metodo ---------------------------------/**
Calcola il valore della corrente
*/
void calcola_corrente();
//---------------------- metodo ---------------------------------/**
mostra i valori di tensione, resistenza e corrente
*/
void mostra_valori();
//---------------------- metodo get ---------------------------------/**
Interroga l' oggetto per ottenere il valore della resistenza
*/
@return
valore
// in ohm
int leggi_resistenza() const;
Pagina 2 di 5
File: /home/peppino/Area_Lavori/ese…orgenti/Oggetti/ohm_classe.cpp
//---------------------- metodo get ---------------------------------/**
Interroga l' oggetto per ottenere il valore della tensione
*/
@return
valore
// in volt
double leggi_tensione() const;
//---------------------- metodo get ---------------------------------/**
Interroga l' oggetto per ottenere il valore della corrente
*/
@return
valore
// in ampere
double leggi_corrente() const;
};// end classe Ohm
..nota il ; per chiudere la classe !
//============== Implementazione delle funzioni membro della classe Ohm ================
//---------------------- costruttore ---------------------------Ohm::Ohm()
{
resistenza = 1;
tensione
= 0.0;
corrente = tensione / resistenza;
}
//---------------------- costruttore ---------------------------Ohm::Ohm( int unaresistenza , double unatensione)
{
resistenza = unaresistenza;
tensione
= unatensione;
corrente = tensione / resistenza;
}
//---------------------- metodo set ----------------------------------
void Ohm::modifica_resistenza(int valore)
{
resistenza = valore;
}
//---------------------- metodo ---------------------------------void Ohm::modifica_tensione(double valore)
{
tensione = valore;
}
//---------------------- metodo ----------------------------------
void Ohm::calcola_corrente()
{
corrente = tensione / resistenza;
}
//---------------------- metodo ---------------------------------void Ohm::mostra_valori()
Pagina 3 di 5
File: /home/peppino/Area_Lavori/ese…orgenti/Oggetti/ohm_classe.cpp
Pagina 4 di 5
{
:" << leggi_tensione() << " Volt\n";
cout <<"\n\n\t La tensione vale
cout <<"\t La resistenza vale :" << leggi_resistenza() << " Ohm\n\n";
:" << leggi_corrente() << " Ampere\n\n";
cout <<"\t La corrente vale
}
//---------------------- metodo get ---------------------------------int Ohm::leggi_resistenza() const
{
return resistenza;
}
//---------------------- metodo get ---------------------------------double Ohm::leggi_tensione() const
{
return tensione;
}
//---------------------- metodo get ---------------------------------double Ohm::leggi_corrente() const
{
return corrente;
}
//********************************
MAIN
***********************************
/**
Il metodo main serve per testare la classe Ohm
*/
int main ( )
{
int R;
// resistenza elettrica
// Ohm circuito;
Ohm circuito = Ohm();
// notazione abbreviata per usare il costruttore predefinito, oppure:
// costruisce l' oggetto con resistenza =1 ohm e tensione 0 volt
cout <<"\n\n\t ***********
Test Classe Ohm ********\n\n ";
circuito.mostra_valori();
circuito = Ohm(1000, 10.0);//reimposta l' oggetto con resistenza =1000 ohm e tensione 10 volt
circuito.mostra_valori();
circuito.modifica_tensione(20.0);
circuito.modifica_resistenza(10000);
circuito.calcola_corrente();
circuito.mostra_valori();
cout <<"\n\n\t ***********
Legge di ohm: calcola corrente ********\n\n ";
//---------------------- come tester.cpp ------------------------------------circuito = Ohm();
// ricostruire l' oggetto
per reimpostare a 0 Volt la tensione
cout << "\n\n\t Immetti il valore della Resistenza [Ohm]: ";
cin >> R;
circuito.modifica_resistenza(R);
cout <<"\n\ncon R = "<< circuito.leggi_resistenza() <<" Ohm si ha:\n\n";
File: /home/peppino/Area_Lavori/ese…orgenti/Oggetti/ohm_classe.cpp
cout <<"--------------------------------\n";
V (volt)
I (ampere)\n";
cout <<"
cout <<"--------------------------------\n";
circuito.calcola_corrente(); // I= V/R
cout << "\t"<< circuito.leggi_tensione() << "\t" << circuito.leggi_corrente();
cout <<"\n--------------------------------\n";
do
{
// V=V+2
circuito.modifica_tensione(circuito.leggi_tensione()+2);
circuito.calcola_corrente(); // I= V/R
cout <<"\t"<< circuito.leggi_tensione() << "\t" << circuito.leggi_corrente() ;
cout <<"\n--------------------------------\n";
}
while ( circuito.leggi_tensione() < 12 );
cout << "\n\n\n";
return 0;
}
Pagina 5 di 5