miércoles, 21 de abril de 2010

Apuntadores en C++

Los apuntadores en C y C++ son una herramienta muy potente de programación que suele causar mucha confusión en los estudiantes que la están aprendiendo.

Cuando se declara una variable, el compilador reserva un espacio de memoria para ella y asocia el nombre de esta a la dirección de memoria desde donde comienzan los datos de esa variable. Las direcciones de memoria se suelen describir como números en hexadecimal.

Un apuntador
Es una variable cuyo valor es la dirección de memoria de otra variable. Se dice que un apuntador “apunta” a la variable cuyo valor se almacena a partir de la dirección de memoria que contiene el apuntador. Por ejemplo, si un apuntador p almacena la dirección de una variable x, se dice que “p apunta a x”.

La Referenciación
Es la obtención de la dirección de una variable. En C y C++ esto se hace através del operador ‘&’, aplicado a la variable a la cual se desea saber su dirección. Nótese que se trata de un operador unario.
Ejemplo:
------------------------------------------------------------------------
Codigo C++

int x = 25;
cout << "La dirección de x es: " << &x <<>------------------------------------------------------------------------

Este código imprime un valor del estilo “0x4fffd34”. Este valor puede variar durante cada ejecución del programa, debido a que el programa puede reservar distintos espacios de memoria durante cada ejecución. Para declarar un apuntador se especifica el tipo de dato al que apunta, el operador ‘*’, y el nombre del apuntador. La sintaxis es la siguiente: *

A continuación se muestran varios ejemplos:

-------------------------------------------------------------------------
Código C++
int *ptr1; // Apuntador a un dato de tipo entero (int)
char *cad1, *cad2; // Dos apuntadores a datos de tipo carácter (char)
float *ptr2; // Apuntador a un dato de tipo punto-flotante (float)
-------------------------------------------------------------------------

Se pueden asignar a un apuntador direcciones de variables a través del operador de referenciación (‘&’) o direcciones almacenadas en otros apuntadores. Ejemplos:

-------------------------------------------------------------------------------
Código C++

int i = 5;
int *p, *q;
p = &i; // Se le asigna a ’p’ la dirección de ’i’
q = p; // Se le asigna a ’q’ la dirección almacenada en ’p’ (la misma de ’i’)
--------------------------------------------------------------------------------

La Desreferenciacion
Es la obtención del valor almacenado en el espacio de memoria donde apunta un apuntador. En C y C++ esto se hace a través del operador ‘*’, aplicado al apuntador que contiene la dirección del valor. Nótese que se trata de un operador unario. Ejemplos:

---------------------------------------------------------------------------------
Código C++

int x = 17, y;
int *p;
p = &x;
cout << "El valor de x es: " << *p << y =" *p">
---------------------------------------------------------------------------------

C++ además provee el operador binario ‘->’, utilizado para obtener campos de un registro con un apuntador al mismo de una manera mas fácil y legible. Muchos compiladores de C también soportan este operador.
Ejemplo 2:

---------------------------------------------------------------------------------
Código C++
struct Data
{
char nombre[20];
int edad;
};
Data d;
Data *pd = &d;
(*pd).edad = 23; // Acceso al campo ’edad’ utilizando el operador ’.’
pd->edad = 23; // Acceso al campo ’edad’ utilizando el operador ’->’
---------------------------------------------------------------------------------------

Tipos de Apuntadores

Apuntadores A Apuntadores
Dado que un apuntador es una variable que apunta a otra, fácilmente se puede deducir que pueden existir apuntadores a apuntadores, y a su vez los segundos pueden apuntar a apuntadores, y así sucesivamente. Estos apuntadores se declaran colocando tantos asteriscos (‘*’) como sea necesario. Ejemplo:
------------------------------------------------------------------------------
Código C y C++
char c = ’z’;
char *pc = &c;
char **ppc = &pc;
char ***pppc = &ppc;
***pppc = ’m’; // Cambia el valor de c a ’m’
------------------------------------------------------------------------------

Apuntadores Constantes U Apuntadores A Constantes
Es posible declarar apuntadores constantes. De esta manera, no se permite la modificación de la dirección almacenada en el apuntador, pero s´ı se permite la modificación del valor al que apunta. Ejemplo:
------------------------------------------------------------------------------

Código C y C++
int x = 5, y = 7;
int *const p = &x; // Declaración e inicialización del apuntador constante
*p = 3; // Esto es valido
p = &y; // Esto no es valido (el compilador genera un error)
------------------------------------------------------------------------------

También es posible declarar apuntadores a datos constantes. Esto hace que no sea posible modificar el valor al que apunta el apuntador. Ejemplo:
------------------------------------------------------------------------------

Código C y C++
int x = 5, y = 7;
const int *p = &x; // Declaración e inicialización del apuntador a constante
p = &y; // Esto es valido
*p = 3; // Esto no es valido (el compilador genera un error)
y = 3; // Esto es valido
------------------------------------------------------------------------------

Apuntadores, Arreglos y Aritmética de Apuntadores
Los arreglos y apuntadores están fuertemente relacionados. El nombre de un arreglo es simplemente un apuntador constante al inicio del arreglo. Se pueden direccionar arreglos como si fueran apuntadores y apuntadores como si fueran arreglos. Ejemplos:
------------------------------------------------------------------------------

Código C y C++
int lista_arr[5] = {10, 20, 30, 40, 50};
int *lista_ptr;
lista_ptr = lista_arr; // A partir de aqu´ı ambas variables apuntan al mismo sitio
cout << p =" &lista[3];" p =" lista" q =" cad;" p =" &x[1]," q =" &x[4];" n =" q">Apuntadores Para Paso De Parámetros Por Referencia
El lenguaje C no provee una manera de pasar parámetros por referencia. Sin embargo, es posible hacerlo a través del uso de apuntadores. A continuación se muestra un ejemplo del paso de un parámetro por referencia en C++, y luego un código equivalente en C o C++ utilizando un apuntador:
------------------------------------------------------------------------------

Código C++
void suma(int a, int b, int& r)
{
r = a + b;
}
void main()
{
int x;
suma(7, 5, x);
cout << "7 + 5 = " << r =" a" 5 =" ">

Bibliografía
El presente articulo fue realizado con la ayuda del libro “Programacion en C++”, del autor Luis Joyanes Aguilar, editorial Mc Graw Hill.


sábado, 17 de abril de 2010

Algoritmos Recursivos

En ciencias de la computación, la recursividad es un elemento muy importante en la solución de algunos problemas. Por definición, un algoritmo recursivo es aquel que utiliza una parte de él mismo como solución al problema. La otra parte generalmente es la solución trivial, es decir, aquella cuya solución será siempre conocida, es muy fácil de calcular, o es parte de la definición del problema a resolver. Dicha solución sirve como referencia y además permite que el algoritmo tenga una cantidad finita de pasos.

La implementación de estos algoritmos se realiza generalmente en conjunto con una estructura de datos, la pila, en la cual se van almacenando los resultados parciales de cada recursión.


Ventajas:

-Algunos problemas son esencialmente recursivos, por lo cual su implementación se facilita mediante un algoritmo de naturaleza recursiva, sin tener que cambiarlo a un método iterativo, por ejemplo. -En algunas ocaciones el código de un algoritmo recursivo es muy pequeño

-Es un método natural de resolver problemas.

-Permite una gran potencia de cálculo.

-La corrección de los algoritmos se comprueba fácilmente.

Desventajas:

-Puede llegar a utilizar grandes cantidades de memoria en un instante, pues implementa una pila cuyo tamaño crece linealmente con el número de recursiones necesarias en el algoritmo. Si los datos en cada paso es muy grande, podemos requerir grandes cantidades de memoria.

Se recomienda aplicar una solución no recursiva cuando el número de cálculos que se repiten sea grande o exista una solución iterativa que sea sencilla de codificar.

Ejemplo Algoritmo Recursivo

__________________________________________________________________
FUNCIÓN Factorial(n)
VAR resultado: Entero

SI (n<2) ENTONCES
resultado = 1;
SINO
resultado = n * Factorial(n-1);
FSI

RETORNA resultado;
FUNCIÓN
__________________________________________________________________

Factores que influyen en el tiempo de un algoritmos

Recursos computacionales:

Diseño del algoritmo Complejidad del problema (p.ej. tamaño de las entradas) Hardware (arquitectura, MHz, MBs…) Calidad del código Calidad del compilador (optimizaciones)

Recursos no computacionales:
Complejidad del algoritmo Disponibilidad de bibliotecas reutilizables

Eficiencia
Tipos de análisis ¿Cómo medimos el tiempo de ejecución de un algoritmo? Mejor caso
En condiciones óptimas (no se usa por ser demasiado optimista).

Peor caso
En el peor escenario posible (nos permite acotar el tiempo de ejecución).

Caso promedio
Caso difícil de caracterizar en la práctica.


miércoles, 14 de abril de 2010

Volker Strassen


Volker Strassen es un matemático alemán, profesor emérito del departamento de matemáticas y estadística de la Universidad de Constanza.
Biografía
Strassen nació el 29 de abril de 1936 en Düsseldorf-Gerresheim. Después de estudiar música, filosofía, física y matemáticas en muchas universidades alemanas, recibió su doctorado en matemáticas en 1962 en la Universidad de Göttingen bajo la supervisión de Konrad Jacobs. Entonces ocupó un puesto en el departamento de estadística de la Universidad de California, Berkeley mientras llevaba a cabo su habilitación en la Universidad de Erlangen-Nuremberg, a donde Jacobs se había trasladado. En 1968, se trasladó al Instituto de Matemática Aplicada de la Universidad de Zurich, donde permaneció durante 20 años antes de trasladarse a la Universidad de Constanza en 1988. Se jubiló en 1998.

Investigación
Strassen nació el 29 de abril de 1936 en Düsseldorf-Gerresheim. Después de estudiar música, filosofía, física y matemáticas en muchas universidades alemanas, recibió su doctorado en matemáticas en 1962 en la Universidad de Göttingen bajo la supervisión de Konrad Jacobs. Entonces ocupó un puesto en el departamento de estadística de la Universidad de California, Berkeley mientras llevaba a cabo su habilitación en la Universidad de Erlangen-Nuremberg, a donde Jacobs se había trasladado. En 1968, se trasladó al Instituto de Matemática Aplicada de la Universidad de Zurich, donde permaneció durante 20 años antes de trasladarse a la Universidad de Constanza en 1988. Se jubiló en 1998.

En 1971 Strassen publicó un documento en conjunto conArnold Schönhage en “Asymptotically fast-integer multiplication (algoritmo Schönhage-Strassen). Él también desarrolló, en 1969, el “Fast-asymptotically matrix multiplication”, ahora conocido como algoritmo de Strassen, aunque su algoritmo es sólo ligeramente más rápido que el algoritmo normal de multiplicacion matriz, él fue el primero a acordar que eliminación de gaus no es ideal.

Bibliografía

martes, 13 de abril de 2010

Bienvenidos

Hola ! es para mi un placer darte la bienvenida a mi blog, espero se sientan comodos Mi nombre es Fernando Arias estudiante de la carrera de Ingenieria en Sistemas en Ceutec espero Dios me de larga vida y sabiduria para poder combinar mi tiempo con mi familia, estudios y mi vida personal.

Actualmente laboro en BAC|Honduras en el area de Tecnologias De Informacion como ing. POS Server.

Naci en la ciudad de Tegucigalpa Fco Morazan el 11 de Octubre de 1977, si sacan la cuenta se daran cuenta que ya soy de la tercera edad, tengo aficion por el futbol, me gusta jugarlo auque ya por tiempo no lo practico habitualmente.

Casado con dos hermosos hijos( lo mas hermoso de mi vida) , tambien me gusta departir con amigos.

Bueno este es un breve resumen de mi y si te das cuenta soy una persona sencilla, gracias por tomarte el tiempo de conocer un poco de mi vida, Gracias.