Memoria Dinámica. Ejercicios dados en clase.

Sábado, 16 de Abril de 2011
#include <condefs.h>
#pragma hdrstop
//--------------------------------------------------------------------------#pragma argsused
#include <stdio.h>
#include <stdlib.h>
void mostrar( int *a, int n )
{
/*
Procedimiento utilizado para mostrar el contenido de un vector de
números enteros.
*/
int i;
printf("\n\n" );
for( i = 0; i < n; i++ )
{
printf("%d\t", a[i] );
}
printf("\n");
}
int * redimensionar( int * a, int n, int n1 )
{
/*
Función que permite "cambiar el tamaño del vector"
a = es el vector pasado como parámetro
n = la cantidad de términos actual del vector.
n1 = El nuevo tamaño del vector en cantidad de términos.
*/
int *x, n2, i;
if( n > n1 )
{
n2 = n1;
}
else
{
n2 = n;
}
x = (int *)malloc( sizeof(int)*n1);
for( i = 0; i < n2; i++ )
{
x[i] = a[i];
}
free(a);
return x;
}
void redimensionarp( int**a, int n, int n1 )
{
/*
PROCEDIMIENTO que realiza lo mismo que la FUNCIÓN "redimensionar"
a = es una variable de PUNTERO a un vector de números enteros. (Variable de doble
puntero)
n = la cantidad de términos actual del vector.
n1 = El nuevo tamaño del vector en cantidad de términos.
Observar como el nuevo vector se pasa guardando la dirección del vector x en la
indirección
de la variable a lo que luego se refleja en el programa que llamó al procedimiento.
Sábado, 16 de Abril de 2011
*/
int *x, n2, i;
if( n > n1 )
{
n2 = n1;
}
else
{
n2 = n;
}
x = (int *)malloc( sizeof(int)*n1);
for( i = 0; i < n2; i++ )
{
x[i] = (*a)[i]; //*(*(a+i))
}
free(*a);
*a = x;
}
main()
{
int *a, i, n;
printf("terminos del vector " );
scanf("%d", &n );
//alocacion de memoria
a = (int *)malloc(n*sizeof(int) );
for( i = 0; i<n; i++ )
{
a[i]=random(1000);
}
mostrar( a, n );
redimensionarp( &a, n, 30 );
mostrar( a, 30 );
free(a);
}
Sábado, 16 de Abril de 2011
#include <condefs.h>
#pragma hdrstop
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//--------------------------------------------------------------------------#pragma argsused
/*
RESOLUCION AL EJERCICIO DADO EN CLASES
Se tiene la siguiente definición de estructuras:
struct punto
{
double x, y;
};
struct vectorfisico
{
punto a, b;
};
Hacer un programa en C para ingresar una cantidad variable de
estructuras vectorfisico a un vector en la memoria dinámica.
Seguidamente ingresarle valores y luego calcular la resultante
de los mismos.
*/
struct punto
{
double x, y;
};
struct vectorfisico
{
punto a, b;
};
double modulo(vectorfisico v)
{
return sqrt(pow((v.a.x-v.b.x),2)+pow((v.a.y - v.b.y), 2) );
}
double argumento(vectorfisico v )
{
double n, d;//numerador y denominador
n = v.a.y - v.b.y;
d = v.a.x - v.b.x;
if ( d == 0 )
{//el angulo es pi /2 o 3*pi/2
if ( n >= 0 )
{//es Pi/2.0??
return M_PI / 2.0;
}
//Caso contrario
return 3 * M_PI / 2.0;
}
//no es ni pi/2 ni 3*pi/2
return (atan( (n/d) ) );
Sábado, 16 de Abril de 2011
}
main()
{
vectorfisico *v;
vectorfisico R; //ahi almaceno la resultante
double arg, mod;
int n, i ;
randomize();
printf("Cuantos vectores quiere componer? " );
scanf( "%d", &n );
v = (vectorfisico *)malloc( sizeof(vectorfisico)*n );//alocamos memoria dinámica
R.a.x = R.a.y = R.b.x = R.b.y = 0; //ponemos a cero r
for( i = 0; i < n; i++ )
{
v[i].a.x = ( ((double)random(1000))/ 13.00) *
((random(20)%2 != 0 ) ? -1.00 : 1.00 );
v[i].a.y = ((double)random(1000))/ 13.00
((random(20)%2 != 0 ) ? -1.00 : 1.00 );
*
v[i].b.x = ((double)random(1000))/ 13.00 *
((random(20)%2 != 0 ) ? -1.00 : 1.00 );
v[i].b.y = ((double)random(1000))/ 13.00 *
((random(20)%2 != 0 ) ? -1.00 : 1.00 );
arg = argumento( v[i] ); //calculamos el argumento
mod = modulo( v[i] );//calculamos el modulos
//acumulamos la resultante
R.a.x += mod * cos(arg);
R.a.y += mod * sin(arg);
}
//al finalizar el ingreso de datos tenemos calculada la resultante
//vamos a mostrar todo
for( i = 0; i < n; i++ )
{
printf( "Vector %d: a(%lf, %lf), b(%lf, %lf )\n",
i,
v[i].a.x,
v[i].a.y,
v[i].b.x,
v[i].b.y );
}
printf( "\n\nRESULTANTE\n\n" );
mod = modulo( R );
arg = argumento(R);
printf( "Modulo = %lf\n", mod );
printf( "Argumento = %lf rads %lf grados\n\n\n", arg, arg * 180.0/M_PI );
free( v ); //liberamos memoria dinámica
system ( "pause");
}