Alexandre Suaide aula 3 c++ e Root. Programa Aula 1 –Introdução ao c++ e ROOT –c++ básico...

Alexandre Suaideaula 3

c++ e Root

Programa

• Aula 1– Introdução ao c++ e ROOT– c++ básico

• Aula 2– Ponteiros/referências– Usando ponteiros cálculo de cinemática

• Aula 3– Classes e objetos– ROOT como ferramenta de programação/análise

• Aula 4– Classes e objetos no ROOT

• Aula 5– Análise de dados no Pelletron (ScanROOT)

Estrutura de dados (struct)struct particula{

float Z;float A;float ELAB;float ECM;float thetaLab;float thetaCM;

};

struct reacao{

particula proj;particula alvo;particula espalhada;particula recuo;float Q;

};

• Criando uma reação

reacao OB;

OB.proj.Z = 8;OB.proj.A = 16;OB.proj.ELAB = 64;

OB.alvo.Z = 5;OB.alvo.A = 10;

OB.espalhada.Z = 6;OB.espalhada.A = 12;

OB.recuo.Z = 7;OB.recuo.A = 14;

OB.Q = 0;

Estrutura de dados

• Note que os dados ficam muito melhores organizados nesta estrutura reacao/particula do que simplesmente em uma lista de variáveis– Emcapsulamento

• Todas informações relevantes estão contidas em uma mesma estrutura

– Primeiro passo para programação orientada a objetos

• Mas alguma coisa está faltando… – O struct somente armazena dados

Objetos e programação orientada a objetos

• Um objeto é uma entidade completa que desempenha uma função específica – Todos os dados e métodos (funções) são internos ao

objeto– Todo objeto é identificado por um nome

• Ex: um automóvel é um objeto.– Um ford-Ka é um objeto do tipo automóvel– Eu posso ter mais de 1 ford-Ka definido em uma rua

de São Paulo porém eles são totalmente independentes

– Eu posso construir tantos ford-Ka quanto necessários • Os parâmetros de construção (cor, combustível, etc)

são definidos unicamente– Eu posso destruir tantos ford-Ka quanto necessários

Classes e objetos em c++

• Classes são os moldes para criação de um objeto em c++

• Objetos são entidades concretas (espaço em memória) criados e organizados com estrutura definida pelas classes

classe

objetos

Classes podem ser derivadas de outras classes

• Em c++ há o conceito de derivação onde classes mais genéricas são criadas e funções/atributos muito específicos de um sub-conjunto são definidas em classes derivadas

Classe genérica

Classes derivadas

Objetos

Na prática – definindo uma classe de objetos

class Bla : public Blu{ protected: <membros protegidos>; private: <membros privados>; public: <membros publicos>;

Bla(); virtual ~Bla();};

Define uma classe chamada

Bla

Esta classe é derivada da classe Blu (caso

necessário)

Os membros e funções

definidas serão tratados como

protegidosOs membros e

funções definidas serão tratados como

privadosOs membros e funções

definidas serão tratados como

públicos

Construtor da classe.

Destrutor (~) da classe.As funções construtoras e

destrutoras DEVEM ter o mesmo nome da classe

Membros de uma classe

• Os membros de uma classe podem ser variáveis, protótipos de funções, ponteiros ou até mesmo objetos de outras classes– Dependem da tarefa a ser executada

• Membros podem ser potected, private ou public– Public

• Não há restrições no acesso a estes membros, sejam em classes derivadas ou pelo usuário

– Protected• Só podem ser acessados pela própria classe ou

classes derivadas– Private

• Só podem ser acessados pela própria classe • Existe um tipo de classe chamada “friend” que pode

acessar todos os membros de outra classe mas o seu uso não é recomendado.

Criando e usando classes

• Criando um objeto da classe teste– teste OBJ1();– teste OBJ2(10);

• Utilizando uma classe– float x = OBJ1.c + OBJ2.c;– OBJ1.d = 10;– float y = OBJ2.func2(10);

• Chamadas ilegais– float s = OBJ1.a;– float k = OBJ1.b + OBJ2.func(1);

class teste{ protected: float a; int b; float func(float); public: float c; float d; int func2(float);

teste(); teste(float); virtual ~teste();};

Um exemplo prático: criando partículas nucleares

• Definiu-se uma classe chamada partícula– Incluimos o arquivo

“math.h” pois a classe efetuará operações matemáticas

– Há dois construtores nesta classe• Posso inicializar os

objetos de duas formas– Todos os membros são

públicos– 3 funções membros– 6 variáveis membros

• Isto é só a definição. E o código para as funções?

#include "math.h"#include <iostream>using namespace std;

class Particula{ public: Particula(); Particula(float, float); virtual ~Particula(); float bind(); float mass(); void imprime(); float Z; float A; float N; float TL; float TC; float EL;};

Arquivo Particula.h

Como definir o código de uma função membro de uma classe?

NOME_DA_CLASSE::NOME_DA_FUNCAO()

• O construtor recebe duas variáveis ZZ e AA que são utilizadas para inicializar o objeto

• O destrutor não faz nada

• A função bind() cálcula a energia de ligação deste núcleo

• A função mass() calcula a massa deste núcleo

• A função imprime() imprime informações sobre o objeto

Particula::Particula(float ZZ, float AA){ Z = ZZ; A = AA; N = A-Z; EL = TL = TC = 0;}Particula::Particula(){ Z = A = N = EL = TL = TC = 0;}Particula::~Particula(){}float Particula::bind(){ // ver site para codigo fonte}float Particula::mass(){ // ver site para codigo fonte}void Particula::imprime(){ cout <<" A = "<<A<<" Z = "<<Z<<" mass =

"<<mass()<<" EL = "<<EL <<" TL = "<<TL<<" TCM = "<<TC<<endl; }

Arquivo Particula.h (continuação) Note que os membros são utilizados como se fossem

variáveis normais

O arquivo Partícula.h

• Neste arquivo está definida a estrutura da classe bem como o código das funções membros– É comum separar em dois

arquivos a definição (estrutura) do código das funções membros

– É uma biblioteca separada

• Cada objeto criado desta classe é uma entidade de memória totalmente separada uma da outra e do resto do programa

#include "math.h"#include <iostream>using namespace std;class Particula{ public: Particula(); Particula(float, float); virtual ~Particula(); float bind(); float mass(); void imprime(); float Z; float A; float N; float TL; float TC; float EL;};

Particula::Particula(float ZZ, float AA){}Particula::Particula(){}Particula::~Particula(){}float Particula::bind(){}float Particula::mass(){}void Particula::imprime(){}

O código foi suprimido somente

para ficar legível

Como criar e usar este objeto?

• Note a criação do objeto P do tipo Particula

• Note como os membros são acessados

• Compilando o programag++ -o teste teste.cxx

• ExecutandoPrompt> ./testeEntre Z e A: 6 12Z = 6 A = 12 N = 6 bind =

179.18 mass = 11088.2

#include "Particula.h"#include <iostream>using namespace std;

int main(){ float Z,A; cout <<"Entre Z e A: "; cin >> Z >> A; Particula P(Z,A);

cout <<"Z = "<<P.Z<<" A = "<<P.A <<" N = "<<P.N <<" bind "<<P.bind() <<" mass = "<<P.mass() <<endl;}

Arquivo teste.cxx

Indo além… classes derivadas

• Vamos pensar na nossa situação da aula passada– Cálculo da cinemática de uma reação

nuclear– 4 partículas

• Feixe, alvo, partícula espalhada e recuo• Ângulos das partículas espalhadas• Energia do feixe• Função claski() para cálculo da cinemática

– Como fazer isto com objetos?• Vamos definir uma classe Kin para descrever

uma reação nuclear.

Definindo uma família de classesCálculo de cinemática de colisões nucleares

Kin

ClasKin

RelKin

Classe básica de uma reação nuclear

Feixe, alvo, partícula espalhada, recuo,

energia, Q

Classe derivada:

Membros e métodos específicos para

realizar os cálculos clássicos de uma colisão nuclear.

Classe derivada:

Membros e métodos específicos para

realizar os cálculos relativísticos de uma

colisão nuclear.

Criando a classe básica (Kin)

• A classe Kin define apenas as componentes necessárias para uma reação nuclear genérica– Feixe, alvo, etc.– Energia, Q

• Neste contexto, esta classe não depende se o cálculo será clássico ou relativístico

#include "Particula.h"#include <iostream>using namespace std;class Kin{ public: Kin(); virtual ~Kin(); void imprime(); Particula feixe; Particula alvo; Particula espalhada; Particula recuo; float Q;};Kin::Kin() { Q = 0; }Kin::~Kin() { }void Kin::imprime(){ cout <<"Feixe: "; feixe.imprime(); cout <<"Alvo: "; alvo.imprime(); cout <<"Espalhada: "; espalhada.imprime(); cout <<"Recuo: "; recuo.imprime(); cout <<" Q da reacao = "<<Q<<endl<<endl;}

Arquivo Kin.h

Criando a classe derivada para cálculo clássico (ClasKin)

• Note que a classe ClasKin é derivada da classe Kin– Todos os membros

da classe Kin são também membros da classe ClasKin

• Note como os membros são utilizados no método calcula()

• Note que o construtor da classe ClasKin executa o construtor da classe Kin– ClasKin::ClasKin():Kin()

#include "Kin.h"class ClasKin : public Kin{ public: ClasKin(); virtual ~ClasKin(); void calcula();};ClasKin::ClasKin():Kin(){}ClasKin::~ClasKin(){}void ClasKin::calcula(){ float pi = 3.1415926; float AP=feixe.mass(); float AT=alvo.mass(); float AO=espalhada.mass(); float AR=recuo.mass(); float A0=sqrt(AO*(AO+AR-AT)/(AT*AR*(1.0+(Q/feixe.EL)*(AO+AR)/AT))); float AAR=A0*AR/AO; float X=A0*sin(espalhada.TL*pi/180); espalhada.TC = atan(X/sqrt(1.0-X*X))*180/pi+espalhada.TL; recuo.TC=-(180-espalhada.TC); recuo.TL=atan(sin(espalhada.TC*pi/180)/(cos(espalhada.TC*pi/180)-

AAR))*180/pi; float RAT=AO/AR*pow((sin(espalhada.TL*pi/180)/sin(recuo.TL*pi/180)),2); espalhada.EL = (feixe.EL+Q)/(RAT+1.0); recuo.EL=feixe.EL+Q-espalhada.EL; return; }

Arquivo ClasKin.h

Criando a classe derivada para cálculo relativístico (RelKin)

• Note que a classe RelKin é derivada da classe Kin– Todos os membros da

classe Kin são também membros da classe ClasKin

• Note que o método calcula tem o mesmo nóme da classe ClasKin mas realiza operações relativísticas e não classicas

• Note que o construtor da classe RelKin executa o construtor da classe Kin– RelKin::RelKin():Kin()

#include "Kin.h"class RelKin : public Kin{ public: RelKin(); virtual ~RelKin(); void calcula();};RelKin::RelKin():Kin() { }RelKin::~RelKin() { }void RelKin::calcula(){ // a geração do código fica como exercício return; }

Arquivo RelKin.h

Criando a classe derivada para cálculo relativístico (RelKin)

• Para compilar no Linux– g++ -o teste2 teste2.cxx

• Note como os vários objetos Particula e ClasKin são criados e utilizados

• Note como nos trabalhamos os vários membros dos objetos

• Note que o programa fica mais intuitivo pois as variáveis que tem significado similares (Z, A, etc) têm o mesmo nome porém em objetos diferentes

#include "ClasKin.h"#include <iostream>using namespace std;int main(){ float Z[4] = {8,5,6,7}; float A[4] = {16,10,12,14}; Particula P[4]; for(int i = 0;i<4;i++) { P[i].Z = Z[i]; P[i].A = A[i]; } ClasKin REACAO; REACAO.feixe = P[0]; REACAO.alvo = P[1]; REACAO.espalhada = P[2]; REACAO.recuo = P[3]; REACAO.Q = 0; REACAO.feixe.EL = 64; float TI = 10, TF = 30, DT = 5; for(float T = TI; T<=TF; T+=DT) { REACAO.espalhada.TL = T; REACAO.calcula(); REACAO.imprime(); } }

Arquivo teste2.cxx

Executando o programa

Resumo

• O que torna o c++ poderoso e versátil é a programação orientada a objetos

• Objetos são criados segundo os seus moldes, definidos pelas classes

• Classes podem derivar de outras classes, formando estruturas hierárquicas de objetos

• Baixem os arquivos do site e modifiquem os programas – Só a prática torna a gente familiar com este tipo de

estrutura

• Próxima aula: ROOT