Alexandre Suaide aula 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: ; private: ; public: ; 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 protegidos Os membros e funções definidas serão tratados como privados Os 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 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 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 programa g++ -o teste teste.cxx Executando Prompt>./teste Entre Z e A: 6 12 Z = 6 A = 12 N = 6 bind = mass = #include "Particula.h" #include 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 classes Cá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 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 = ; 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 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