UFRO Master Fisica Medica 5 2 Programando C

5. Técnicas de Simulación

2. Programando C++

Objetivos: Dominar C++ al nivel necesario para poder

armar programas que simulen en base a

Geant4.

1

www.gphysics.net – UFRO-2008-Master-Fisica-Medica-5-2-Programando C++-05.09

Dr. Willy H. Gerber

Instituto de Fisica

Universidad Austral

Valdivia, Chile

Programa para armar programas

Trabajaremos con Visual Studio 2008

2



Creemos un proyecto…

3



… en C++ :

4



Estructura creada:

5



Ejecutar:

6


Ejemplo simple

// UFROTest.cpp : main project file.

#include "stdafx.h"

Comencemos con un ejemplo simple:

Comentario (línea que comienza con //)

Inicio programa principal (main)

7


using namespace System;

int main(array<System::String ^> ârgs)

{

Console::WriteLine(L"Hello World");

Console::ReadLine();

return 0;

}

Otro ejemplo

Otro ejemplo, con dos línea:

int main(array<System::String ^> ârgs)

{

Console::Write(“Adios ");

Console::WriteLine(“mundo cruel");


return 0;

}

8


Los espacios no son considerados en la compilación. O sea también se podría escribir:}

int main(array<System::String^> ârgs) { Console::Write(“Adios");

Console::WriteLine(“mundo cruel"); Console::ReadLine(); return 0; }

Variables

string^ s=“Hola”;

En el ejemplo se introdujo el concepto de texto (string) que se

escribe entre “:

Existen además por ejemplo:

int n=2;

char c=‘h’;

números enteros

caracteres

9


char c=‘h’;

float x=5.67;

double y=2.345;

bool decision=true;

caracteres

números reales (baja precisión)

números reales (alta precisión)

valor lógico

Nota, es muy distinto 2, ‘2’, “2” y 2.0 (porque?)

int n;

n=2;

Ejemplo de definición y asignación

int n;

n=‘2’;

Ejemplo de error

Operadores sobre int y float

Los operadores básicos son:+ suma

- resta

* multiplicación

/ división

% modulo

++ incrementa en 1

Los operadores pueden ser empleados para asignar valores y/o para entregar valores:

10


float a, b, x, y;

a=1.2;

b=0.2;

x=5.1;

y=a*x+b/x;

Console::WriteLine(2*(x/a)+b);

Nota: En el calculo primero se aplican * y /, luego + y -.

Las operaciones se hacen de izquierda a derecha.

Operadores sobre char , conversión y char de string

char letra;

letra = 'a' + 1;

Console::WriteLine(letra);

El carácter se asocia al código ASCII:

Entrega como resultado ‘b’

int numero;

numero = 'a';

Console::WriteLine(numero);

Entrega como resultado 97

11


Console::WriteLine(numero);

Conversión de tipos (typecast)

double x=2.6;

int n=(int)x;

Asocia a n el valor 2

(cuidado, trunca, no redondea)

Cada string es una colección o arreglo de char’s, por ello

String^ nombre (“test”);

char primera_letra=nombre[0];

char segunda_letra=nombre[1];

Asigna la ‘t’ a primera_letra

Asigna la ‘e’ a segunda_letra

Funciones matemáticas

Si se agrega al inicio la referencia a las funciones matemáticas:

#include <math.h>

se pueden usar las funciones matemáticas que incluye el C++, calculando y asignando

valores como por ejemplo

y=cos(x)

12


Las funciones que incluye el C++ son: abs

acos

asin

atan

atan2

ceil

cos

cosh

exp

fabs

floor

fmod

frexp

ldexp

log

log10

modf

pow

sin

sinh

sqrt

tan

tanh

Generadores random

En la librería:

#include <stdlib.h>

Esta definida el generador de números al azar

rand ();

Genera números enteros entre 0 y RAND_MAX

13


int x = rand ();

double y = (double)x/RAND_MAX;

Para generar un numero real entre 0 y 1:

Cuidado, el seed (semilla, valor inicial de la secuencia) es siempre el mismo, o sea

la secuencia es siempre la misma. Si se desea cambiar esto se debe variar el seed.

Funciones propias

Los programas permiten la definición de funciones o subrutinas propias.

Un ejemplo podría ser una función “writeMessage” que se “encargue” de enviar un

mensaje a la pantalla.

Se definen “en paralelo” al programa principal que lo llama:

#include <iostream.h>

void writeMessage (String^ txt)

14


void writeMessage (String^ txt)

{

Console::WriteLine(“Mensaje: ”+txt);


}

void main ()

{

writeMessage("Hola.“);

}

Existen también librerías que traen funciones que pueden ser llamadas, Geant4 es una

muy completa para cálculos de dinámica de partículas.

Funciones propias

Las subrutinas pueden:

- Tener múltiples argumentos (Nota: cada argumento tiene que llevar su tipo,

ejemplo: int n, int m, float x … es ilegal tratar de resumir: int n, m, float x

- Pueden devolver un valor, el que se especifica en la definición de la subrutina y

en el valor que entrega:

double poly(double x)

15


double poly(double x)

{

double u=1+2*x+3*pow(x,2);

return u;

}

void main ()

{

Console::WriteLine(“P(2.5)=”+poly(2.5));


}

Condicionamientos

En el desarrollo del programa se pueden condicionar la ejecución de una

serie de instrucciones:

if (condicion1) {

instrucciones1

} else if(condicion2){

instrucciones2

} else{

instrucciones3

}

Si se da la condicion1…

… realiza instrucciones1

… si no se dio condicion1 pero si condicion2


… y si no se dio ni condicion1 ni condicion2


16


}

Las condiciones se definen como

x==y

x!=y

x >y

x >=y

x <y

x <=y

x es idéntico de y

x es diferente a y

x mayor que y

x mayor o igual que y

x menor que y

x menor o igual que y

Nota: pueden existir el numero que se quiera de else if (incluido ninguno) y existir

o no el else final. Las instrucciones pueden también contener condiciones if

Abortar y recurrencia

Si se desea abortar una subrutina basta con incluir el comando:

return;

Y el sistema volverá al punto donde se llamo la subrutina (en el main o en la

subrutina que sea).

C y C++ tienen además la posibilidad de realizar llamadas recurrentes, o sea la

subrutina se llama a si misma:

17


subrutina se llama a si misma:

void ConteoRegresivo(int cnt)

{

if(cnt==0) {return;}

else{

Console::WriteLine(cnt);


ConteoRegresivo(cnt-1);

}

}

Variables lógicas

Alternativas

bool flag;

flag = true;

flag = false;true=verdadero

false=falso

Determinar variable lógica, ejemplos:

flag=(x!=0); Si x es distinto de cero, flag es verdadero, si no falso.

18


flag=(x!=0);

flag=(n>0);

Si x es distinto de cero, flag es verdadero, si no falso.

Si n es mayor que cero, flag es verdadero, si no falso.

Operadores lógicos:

&&

||

!

And

Ir

Nota

flag12=flag1 && flag2

flag12=flag1 || flag2

flag2=!flag1

Loops - while

El loop while(){}

El loop (circulo cerrado) mas simple es el while simple:

while(condición){

instrucciones

}

Que se repite mientras que la condición se cumpla. Por ello las instrucciones

19


Que se repite mientras que la condición se cumpla. Por ello las instrucciones

deben contener algún cambio que lleve finalmente a que la condición no se

cumpla y pueda salir del loop (error en la ejecución, el compilador no descubre

estos problemas).

n=10

while(n>0){

n=n-1;

}

Loops - for

El loop for(){}

Otro loop (circulo cerrado) es el for:

for(int i=inicio;limite;i++ o i--){

instrucciones

}

Ejemplo:

20


Ejemplo:

for (int i = 0; i < 4; i++) {

}

Operaciones sobre strings

Largo de un string

String^ txt (“text”);

int len=txt.length(); Asigna a león el valor 4

Posición de char en string


int idx=txt.find(‘x’); Asigna a idx el valor 3

21


int idx=txt.find(‘x’); Asigna a idx el valor 3


int idx=txt.find(‘ex’); Asigna a idx el valor 2

Concatenar strings

String^ txt1 (“te”);

String^ txt2 (“xt”);

String^ txt (“”);

txt=txt1+txt2;

Estructuras

Estructuras

struct nombre {

double fvariable1, fvariable2;

int nvariable1;

…

};

struct Point {

double x, y;

};

Ejemplo

22


Elementos de la estructura:

nombre.fvariable1

Asignación de valores a estructura (solo al crear!):

nombre ejemplo = {1.0, 2.3, 2, …}

Asignación de estructura:

nombre ejemplo2 = ejemplo1;

(también se pueden

hacer asignaciones de

estructuras)

Estructuras

Las estructuras se pueden usar igual que los otros tipos de variables.

En particular se pueden pasar como argumentos:

void subrutina(nombre p, …)

Lo que significa que una copia (no la misma estructura) es creada en la subrutina.

Si se desea hacer referencia a la estructura original se debe pasar la dirección a la

memoria:

void subrutina(nombre& p, …)

23


void subrutina(nombre& p, …)

Las estructuras pueden ser retronadas por las subrutinas

nombre subrutina(…){

nombre p;

…

return p;

}

Si se quiere evitar que modificaciones en la subrutina repercutan en la rutina que

hace la llamada se puede “bloquear” la modificación agregando const:

void subrutina(const nombre& p, …)

Estructuras

Funciones a ser llamadas en estructuras

struct Tiempo {

int hora, minutos;

double segundos;

void Tiempo::imprimir ();

};

24


void Tiempo::imprimir () {

Tiempo hoy = *this;

instrucciones

}

en que se llama vía el puntero this la estructura. En todo caso se pueden citar

en la función directamente las variables como serian hora, minutos y segundos.

};

La función en si seria

Punteros y Referencias

Punteros

int* x o int *x

Referencia

*px = &x;

add*px

&rx

x valadd

El puntero *px

contiene la dirección

de donde esta el valor x

25


int& x o int &x &rx = x;

x = 1;

lvalue = rvalue;

x valaddLa referencia &rx

retorna el valor x

Alocución de memoria dinámica y arreglos

int *pint;

pint = new int;

delate pint;

Definir puntero

Reservar memoria

Liberar memoria

int n = 10;

int *parray;

parray = new int[n];

26


parray = new int[n];

delte parray;

Puntero y referencia en subrutinas

tipo *funcion(tipo *p)

{

...

...

return p;

}

27


tipo &funcion(tipo &r)

{

...

...

return r;

}

Estructuras generales y Archivos “Headers”

Una estructura general tiene la forma:

struct nombre {

// instance variables

variables (ej. double x, y; int n;)

// constructors

funciones que asignan valores (ej set(int n, double x, double y); set(int n); )

// modifiers

28


// modifiers

funciones de modificación (ej. void change (double x, double y); )

// functions

funciones “de trabajo” (ej. void print (int n) const; )

};

#include “nombre.h”

La definición se graba en un archivo .h que se cita en el programa main como:

Las funciones se escriben en el archivo

nombre.cpp

Clases

Las class son estructuras en que las variables son de uso exclusivamente

Internas y no pueden ser modificadas externamente (privadas)

Ejemplo

class Complex

{

private:

double real, imag;

Complex (double r, double i)

{

real = r; imag = i;

cartesian = true; polar = false;

}

29


double real, imag;

double mag, theta;

bool cartesian, polar;

void calculateCartesian ();

void calculatePolar ();

public:

Complex () { cartesian = false; polar = false; }

void printCartesian ();

void printPolar ();

double getReal ();

double getImag ();

double getMag ();

double getTheta ();

void setCartesian (double r, double i);

void setPolar (double m, double t);

};

Date post:	06-Jul-2015
Category:	Education
Upload:	willy-h-gerber
View:	946 times
Download:	2 times

UFRO Master Fisica Medica 5 2 Programando C

Education