alexandre suaide aula 3 c++ e root. programa aula 1 –introdução ao c++ e root –c++ básico...
TRANSCRIPT
![Page 1: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/1.jpg)
Alexandre Suaideaula 3
c++ e Root
![Page 2: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/2.jpg)
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)
![Page 3: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/3.jpg)
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;
![Page 4: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/4.jpg)
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
![Page 5: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/5.jpg)
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
![Page 6: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/6.jpg)
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
![Page 7: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/7.jpg)
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
![Page 8: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/8.jpg)
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
![Page 9: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/9.jpg)
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.
![Page 10: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/10.jpg)
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();};
![Page 11: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/11.jpg)
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
![Page 12: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/12.jpg)
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
![Page 13: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/13.jpg)
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
![Page 14: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/14.jpg)
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
![Page 15: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/15.jpg)
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.
![Page 16: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/16.jpg)
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.
![Page 17: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/17.jpg)
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
![Page 18: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/18.jpg)
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
![Page 19: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/19.jpg)
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
![Page 20: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/20.jpg)
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
![Page 21: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/21.jpg)
Executando o programa
![Page 22: 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](https://reader036.vdocuments.mx/reader036/viewer/2022062302/5706384c1a28abb8238f617c/html5/thumbnails/22.jpg)
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