Documentos de Académico
Documentos de Profesional
Documentos de Cultura
17/08/2017
V. MARCO TEORICO.
APUNTADORES
Los apuntadores permiten acceder a cualquier bloque de memoria que se desee, pero
existen restricciones:
Debe tener permisos del sistema operativo para acceder a la memoria (la
memoria accedida debe haber sido asignada a su programa).
Debe saber dónde se ubica el bloque de memoria que quiere acceder. Para
muchas aplicaciones, saber esta información es fácil porque la memoria habrá
sido asignada al programa, y le será dado al programa la dirección de memoria.
Si la memoria es un bloque común, como un buffer de video, la memoria será
ubicada en una posición fija o un apuntador a la memoria se encontrará en una
ubicación conocida.
Cuando se usa apuntadores, se debe indicar al compilador el tamaño del objeto al cual
se hará referencia. Por ejemplo, un apuntador a un carácter ( char) apunta a un elemento
de 8 bits, un apuntador a un entero ( int) apunta a un elemento de 16 bits, un apuntador
a un entero largo (long) apunta a un elemento de 32 bits. Un apuntador puede
incrementarse o decrementarse para referenciar a un siguiente elemento, por lo que el
compilador necesita esta información porque así podrá determinar la distancia a la cual
se encuentra el siguiente objeto que debe ser referenciado.
DECLARACION DE APUNTADORES
Cuando se declara un apuntador, se utiliza un modificador de tipo, para indicar que este
apuntará a una variable de ese tipo, no que el apuntador será de ese tipo. Por ejemplo:
int contador = 0;
int *ptrContador;
ptrContador = &contador
En el siguiente ejemplo, se crean dos variables. Primero se crea e inicializa una cadena
de caracteres llamada cadena y luego se crea un apuntador a dicha cadena.
ptrCadena = cadena;
ptrCadena = &cadena;
ptrCadena =
&cadena[0];
INDIRECCION
En el siguiente ejemplo:
Una estructura es una agrupación de variables organizadas de forma que pueden ser
referidas por un mismo nombre. A diferencia de los arreglos, las variables que conforman
una estructura pueden ser de tipos diferentes.
DECLARACIÓN DE ESTRUCTURAS
Por ejemplo:
struct punto
{
int x;
int y;
};
struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
char puesto[10];
};
Por ejemplo:
struct punto
{
int x;
int y;
} Origen; //Se define y crea la variable Origen de tipo
punto
struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
char puesto[10];
} fijo, temporal; //se define y crea las variables fijo
y temporal, ambas de tipo trabajador
Asignación de valores:
Por ejemplo:
Origen.x = 0;
temporal.edad=25;
Lectura de valores:
Por ejemplo:
UNION
Similar a una estructura. Con la diferencia que mientras que una estructura reserva
espacio para cada variable, una unión reserva especio solamente para la variable más
grande y ese espacio es compartido por todas las variables. Como resultado, solo una
variable puede ser almacenada a la vez.
La definición de una unión, así como el acceso a sus campos se realiza de la misma
forma en que se gestionan las estructuras.
Por ejemplo
union parametros
{
int nro;
int *ptrNro;
};
La forma de crear variables del tipo de una unión obedece al siguiente formato:
union <Nombre del tipo de la union> <Nombre de variable
union>;
Por ejemplo:
union parametros
{
int nro;
int *ptrNro;
} primerElemento; //define la unión parámetros y
crea la variable primerElemento de
tipo parametros.
Asignación de valores:
Por ejemplo:
primerElemento.nro = 10;
primerElemento.ptrNro = &primerElemento.nro;
En este ejemplo, luego de ejecutarse la segunda asignación, el valor del campo nro será
sobrescrito por su dirección.
Lectura de valores:
Por ejemplo:
int x = primerElemento.nro;
VI. DESARROLLO DE LA PRACTICA
Solución
//Nombre : apuntadores
//Proposito : Muestra el contenido de una variable
de manera directa e indirecta
//Autor : Edwin Carrasco
//FCreacion : 23/11/2011
//FModificacion : 21/02/2013
#include <stdio.h>
main ()
{
//Variables
int var =
300;
int *ptr; //Apuntador a una variable entera
ptr = &var; //Inicialización de puntero. ptr almacena la
direccion de var
2. Escriba un programa que muestre los elementos de tres arreglos que almacenen
datos de tipo short, int y doublé. Además de los datos almacenados, el programa
debe mostrar las direcciones de memoria en que se almacenan estos datos.
Solución
//Nombre : dirArreglos
//Proposito : Muestra las direcciones y contenido de
los elementos de arreglos de tipos
short, int y double.
//Autor : Edwin Carrasco
//FCreacion : 21/02/2013
//FModificacion : ---
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
int main()
{
//Variables
int i;
short arreglo_s[10];
int arreglo_i[10];
double arreglo_d[10];
//Crearemos datos
aleatorios for(i = 0; i <
10;i ++)
{
arreglo_s[i] = (short)(1+rand()
%(999)); arreglo_i[i] = (int)(1+rand()
%(99999));
arreglo_d[i] = (double)((1+rand()%(999999999-1))*0.1f);
}
//Mostrar salida
printf("\n==============================");
printf("==============================\n");
printf("\t\tSHORT\t\tINT\t\tDOUBLE\n");
printf("\t Direc : cont | Direc : cont | Direc:
cont");
printf("\n==============================");
printf("==============================");
printf("\n=============================");
printf("===============================");
//Salir
return 0;
}
3. Escriba un programa que halle la distancia entre dos puntos definidos por sus
coordenadas (x, y) en el espacio. Las coordenadas se deben almacenar en una
estructura.
Solución
//Nombre : distancia
//Proposito : Calcula la distancia entre dos puntos
en el espacio
//Autor : Edwin Carrasco
//FCreacion : 21/02/2013
//FModificacion : ---
#include <stdio.h>
#include <math.h>
//Variables globales
struct coordenada{
int x;
int y;
};
main ()
{
//Variables locales
struct coordenada
punto1; struct
coordenada punto2;
double distancia;
//Procesar
distancia = sqrt(pow(punto2.x-punto1.x,2)
+ pow(punto2.y -
punto1.y,2));
//Mostrar resultados
printf("La distancia entre los puntos ingresados es
%.2f\n", distancia);
}
4. Escriba un programa que permita la administración de un catálogo de libros. Los
datos de un libro se almacenan en una estructura.
Solución:
//Nombre : libreria
//Proposito : Administra un catalogo de libros
//Autor : Edwin Carrasco
//FCreacion : 01/12/11
//FModificacion : --
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
printf("Ingrese el autor:
"); scanf("%s", l->autor);
void mostrarMenu()
{
puts("******** SISTEMA DE GESTION DE LIBROS
***********"); puts("* *");
puts("* 1. Insertar Libros *");
puts("* 2. Mostrar Catalogo *");
puts("* 3. Buscar por titulo *");
puts("* 4. Buscar por autor *");
puts("* 5. Salir *");
puts("* *");
puts("*************************************************");
}
main()
{
//Variables
struct tLibro
catalogo[tam]; char
datos[21];
int opcion=0;
int i=0;
int j;
do
{
//Indicar que hace el
programa mostrarMenu();
//Leer datos
printf("\nIngrese una opcion:
"); scanf("%d",&opcion);
switch (opcion)
{
case 1:
//Agregar titulos
if (i < tam)
{
leerDatos(&catalogo[i]);
i++;
}
break;
case 2:
//Mostrar catalogo
for(j = 0; j < tam; j++)
mostrarDatos(&catalogo[j]);
break;
case 3:
//Buscar por titulo
printf("Ingrese el titulo del texto:
"); scanf("%s", &datos);
puts(datos);
if(buscarTitulo(catalogo,datos))
else
printf("El te en la
titu biblioteca\n\n");
lo
exis printf("El titulo no existe en
la biblioteca\n\n");
break;
case 4:
break;
case 5:
break;
default:
puts("La opcion no es
correcta!!"); break;
}
}while (opcion != 5);
}
5. Escriba un programa que almacene el salario de un trabajador en soles y dólares
utilizando una unión
Solución
//Nombre : salario
//Proposito : Almacena el salario de un trabajador
//Autor : Edwin Carrasco
//FCreacion : 21/02/2013
//FModificacion : ---
#include <stdio.h>
main ()
{
//Variables
union Salario
{
int enSoles;
float enDolares;
};
//Procesar
SalarioJuan.enSoles =
2580;
//Mostrar resultados
//Imprimir en pantalla el Salario de Juan en
Soles printf("Salario de Juan en Soles = %d\n",
SalarioJuan.enSoles);
IX. BIBLIOGRAFIA
1. Deitel & Deitel, “Como Programar En C/C++”. 2da edición. Prentice Hall
2. Hipson, P. “Advanced C”. Sam Publishing. 1992
3. Joyanes L., “Microsoft C/C++ 7. Manual De Bolsillo”. Ed. McGraw Hill 1994
4. Marquez, M. “UNIX. Programación Avanzada”. 2da edición. Editorial Alfaomega
2001.
5. Prata S. “C++ Primer Plus” 5ta edición. Editorial SAMS 2005.