Ingeniero Técnico en Informática de Sistemas
Fundamentos de Programación
PASO DE ARGUMENTOS A UNA FUNCIÓN "POR VALOR "
Cuando se le pasa un valor a una función mediante un argumento actual, se copia el valor del argumento actual al argumento formal de la función (el formal es el que ponemos en la declaración de la función) por lo tanto se puede modificar el valor del argumento formal dentro de la función , pero el valor del argumento actual en el punto de la llamada a la función no cambiara. (A esto se le llama paso por valor)
Ejemplo:
#include <stdio.h>
void modificar(a) //tambien se puede declarar poniendo en vez de 'a', 'int a' y no pones la
linea siguiente
int a; //variable local, solamente reconocida por la funcion. Declarada dentro de la funcion
{
a=a*3;
printf("%d",a);
return; //no devuelve ningun valor por que el valor de 'a' en el programa principal no se
modifica. Si la funcion devolviera el valor de 'a' y lo guardaramos en a=modificar(a)
(linea 14), el valor de 'a' quedar¡a modificado tambien en el programa principal
}
void main()
{ //main, al fin y al cabo es otra funcion
int a=2; //variable local
clrscr();
printf("%d",a);
modificar (a);
printf("%d",a);
}
resultado=262.
Con este ejemplo vemos que aunque demos el mismo nombre a los argumentos, no va a dar ningún problema (usamos el argumento a en ambas funciones).
Ventaja : Permite proporcionar una expresión ( a*2+4....)como argumento actual
Problema : Impide que se transfiera información desde la función hacia el punto de llamada mediante los argumentos, por lo tanto al transferencia de información sólo se realiza en un sentido, desde el punto de la llamada hacia la función.
N - LA FORMA DE PASAR INFORMACIÓN A LAS FUNCIONES , SON LOS ARGUMENTOS, ESTOS SON LOS FORMALES (LOS VALORES QUE LE PASAS A LA FUNCION), EN EL PUNTO DE LLAMADA A LA FUNCION (DENTRO DEL PRINCIPAL) SON LOS ACTUALES, QUE ME SIRVEN PARA PASAR A LA FUNCIÓN UN VALOR DETERMINADO CON EL QUE TRABAJAMOS EN ESE MOMENTO.
“A la hora de pasar parámetros a la función en c hay que tener en cuenta que todos se pasan por valor, es decir, se pasa una copia temporal del parámetro, no el parámetro en si.
Esto significa que la función no puede modificar las variables externas a ella, ya que le ha sido pasada una copia y no el valor original. Un parámetro por valor se pude entender como una variable local, de modo que dentro de la función puede cambiar su valor pero los cambios no tienen efecto fuera de ella.
Sin embargo, en la mayoría de las ocasiones, lo que queremos es que los parámetros que pasamos a la función cambien de valor. Para conseguir eso, lo que debemos de usar es el paso de parámetros por referencia. Quiere esto decir que lo que se pasa a la función no es una copia del parámetro sino el argumento.
El paso de parámetros por referencia es sinónimo en C de paso de direcciones de memoria, es decir la función conoce la dirección de memoria donde están almacenados los parámetros que se la pasan. La forma de hacer esto en C es utilizando punteros, de modo que lo que pasamos es un puntero a los parámetros a modificar.
#include <stdio.h>
void modificar ( *a )
int a;
{
*a= *a * 3;
printf("%d", *a);
return;
}
void main ()
{
int a=2;
printf ( "%d", a);
modificar (&a) ;
printf ( "%d", a);
}
Resultado=266.
¿Qué ha ocurrido? .En primer lugar, sigue siendo cierto que en C todos los parámetros se pasan por valor. Pero en este caso lo que se ha pasado a la función no ha sido el contenido de las variables, lo que se ha pasado ha sido la dirección de memoria de la variable “a” .
Dichas direcciones se no varían al salir de la función sino lo que se ha modificado ha sido el contenido de esa dirección de memoria. Dentro de la función se trabaja con las direcciones como punteros.
Un aspecto muy importante relacionado con el paso de parámetros por referencia es el retorno de valores por parte de una función. Sabemos que en C una función solo puede devolver un valor, por este motivo es aconsejable utilizar el paso por referencia para retornar mas valores.
Otro motivo para usar el paso por referencia es el ahorro de espacio y tiempo ya que si queremos pasar a la función algo que ocupe mucho en memoria, es conveniente hacerlo por referencia. Si lo hacemos por valor, perdemos mucho tiempo y espacio; ya que tiene que hacer una copia y colocarla en la pila. “
VARIABLES GLOBALES O EXTERNAS
Hay diferentes tipos de variables, entre las cuales estan las que hemos venido utilizando hasta ahora(variables locales) y las variables globales .
-
Variables locales:
Son aquellas declaradas en el cuerpo principal de un programa, es decir en el cuerpo de la función MAIN , son privadas a esa función, es decir, son variables locales de función main. Esto implica que ninguna otra función puede tener acceso a ellas.
Lo anterior es valido para las variables de otras funciones. Esto hace que en distintas funciones pueda haber variables con el mismo nombre sin ningún problema. (Ejemplo: los contadores i,j).
Las variables locales empiezan a existir cuando se llama a la función y desaparecen cuando acaba la función. Por esta razón reciben el nombre de variables automáticas las cuales aparecen y desaparecen con cada invocación de la función en las que están declaradas. para garantizar su contenido se han de inicializar al entrar a la función. en caso contrario tendrán un valor indeterminado.
-
Variables globales o externas:
Como alternativa a las variables automáticas es posible definir variables externas a todas las funciones.
A estas variables se las califica de globales. Cualquier función puede utilizarlas sin mas que usar su nombre.
Las variables globales pueden utilizarse en lugar de los argumentos de las funciones para comunicar datos entre las mismas. Además mantienen sus valores, ya que existen permanentemente, incluso después de finalizar las funciones que las modifican, sin embargo el uso excesivo de este tipo de variables atenta contra la programación estructurada.
Este tipo de variables, al contrario que las automáticas, no están confinadas a funciones simples. Su ámbito se extiende desde el punto de definición hasta el resto del programa, por lo tanto, serán reconocidas por más de una función y a menudo por todo el programa.
Como las variables externas se reconocen globalmente pueden accederse desde cualquier función que caiga dentro de su ámbito, y mantendrán los valores asignados dentro de éste ámbito, por lo tanto, a una variable de éste tipo de le puede asignar un valor dentro de una función y este valor se puede usar accediendo a la variable en otra función distinta. El uso de éste tipo de variables permite transmitir información entre funciones sin el uso de argumentos, lo que es especialmente útil cuando una función requiere muchos datos de entrada o queremos proporcionar muchos datos de salida.
-
#include <stdio.h>
int a=0; //declaramos la variable global, que va a ser reconocida por todo el programa (esta
declarada fuera del programa (antes de main)). Se reconocen a partir del punto en que se
declaran hacia abajo, asi que en este caso si lo ponemos justo antes de main dejando arriba
la funcion nos va a dar un error porque la funcion no reconoce la variable
void funcion()
{
a=a*3; //sabe que a=2 porque es una variable global
printf("%d",a); //el valor a se modifica y queda modificada en el programa
principal
return;
}
void main()
{
a=2; //inicializamos la variable global a=2
clrscr();
printf("%d",a);
funcion(); //no enviamos ningun valor a la funcion
printf("%d",a);
}
resultados =2 6 6
-
#include <stdio.h>
void funcion() {
a=a*3;
printf ("%d", a);
return;
}
int a=0;
void main () {
a=2;
printf ( "%d", a);
funcion ();
printf("%d", a);
}
resultado = error porque hay que declarar la variable antes de una
funcion si se utiliza en esta
-
#include <stdio.h>
void funcion ( int a ) {
a=a*3;
printf ("%d", a);
return;
}
int a=0;
void main () {
a=2;
printf ( "%d", a);
funcion ();
printf("%d", a);
}
resultado = 2 6 2
-
#include <stdio.h>
int funcion() {
a=a*3;
printf ("%d", a);
return(a);
}
int a=0;
void main () {
a=2;
printf ( "%d", a);
a= funcion ( a );
printf("%d", a);
}
resultado = 2 6 6
-
Programa sobre las variables globales
#include <stdio.h>
int a,b,c; //declaracion de variables globales
void mezcla (int y,int z) //toman los valores de a y b
{
int x;
x=y; //x=1 x=1
y=z; //y=2 y=3
z=c; //z=3 z=3
c=x; //c=1 c es variable global y ese cambio se mantiene. c=1
return;
}
void lanza (int a, int b) //la funcion no devuelve ningun valor y a y b en este caso actuan como
variables locales, por lo que no van a cambiar en el programa principal. En esta funcion solo cambia c.
{
int x;
x=c; //x=1 toma el valor de c, que se ha cambiado antes x=2
c=b; //c=2 c=2
b=a; //b=1 b=-1
a=x; //a=1 los valores de a y b se pierden porque son locales. a=1
return;
}
void main(){
a=1; b=2; c=3;
clrscr();
printf("%d%d%d\n",a,b,c);
mezcla (a,b);
printf("%d%d%d\n",a,b,c);
lanza (a,b);
printf("%d%d%d\n",a,b,c);
a=1; b=2; c=3;
mezcla (a,b+1); //van a llegar a la funcion con a=1 y b=3 aunque b sigue valiendo 2
printf("%d%d%d\n",a,b,c);
lanza (a-b,b); //van a llegar a la funcion con a=-1 y b=2 aunque a sigue valiendo 1. Ahora a y b
son variables locales y la funcion no devuelve nada por lo que los valores de a y b no van a variar
printf("%d%d%d\n",a,b,c);
}
resultado= 123,121,122,121,122;
-
Programa sobre las variable globales
#include <stdio.h>
int a,b,c,d;
void cambia (int a, int g, int y) //queda declarado 'a' como local, por lo que al no devolver ningun
valor la funcion no va a cambiar en el programa principal
{
int b,c; //queda declarado 'b' y 'c' como local.
b=a+g-y; //en la funcion estan declaradas como local 'a', 'b' y 'c'. Solo puede
cambiar la variable 'd' pero en la funcion no se le da ningun nuevo valor
g=b+d;
c=1;
a=a+b+d-c;
y=c+g-a;
return;
}
void main(){
a=1; b=2; c=3; d=4;
clrscr();
cambia(b,c,d);
printf("%d%d%d%d\n",a,b,c,d);
cambia(b,a,c);
printf("%d%d%d%d\n",a,b,c,d);
getch();
}
resultado=1234 1234
-
Programa sobre las variable globales
#include<stdio.h>
int a,b,c;
void uno(int a,int x, int y)
{
int b,d;
b=x+y-a;
d=(a*y)-(a*b);
c=a*y-d;
x=a*c-d;
a=b+d+x-y;
y=y+a+b+c+d+x;
return;}
void main()
{
a=1;
b=2;
c=3;
printf("%d%d%d",a,b,c);
uno(b,c,a);
printf ("%d%d%d",a,b,c);
}
resultado= 123,124.
-
Programa sobre las variables globales
#include <stdio.h>
int a,b,c;
void uno(int d, int x, int y)
{
b=x+y-a;
d=(a*y)-(a*b);
c=a*y-d;
x=a*c-b;
a=b+d+x-y;
y=y+a+b+c+d+x;
return;
}
void main()
{
a=1;
b=2;
c=3;
printf("%d%d%d\n",a,b,c);
uno (a,b,c);
printf("%d%d%d\n",a,b,c);
uno (b,c,a);
printf("%d%d%d\n",a,b,c);
}
resultado: 123,044,040
RECURSIVIDAD:
Se llama así al proceso mediante el cual una función se llama así misma repetidas veces hasta que se satisface una condición, este proceso se utiliza para cálculos repetitivos en los que cada resultado se determina en función del anterior. Se pueden escribir de esta forma muchos problemas interactivos.
Se tienen que satisfacer dos condiciones para resolver un problema recursivamente:
-
Que el problema se pueda escribir de forma recursiva
-
Que contenga una condición de fin para terminar con el problema.
A veces una función recursiva es conceptualmente mas clara que una iterativa. si utilizas funciones recursivas lo que nunca se debe olvidar es colocar alguna sentencia de tipo IF, que permita que exista una situación en que se ejecute la función sin volver a llamarse a si misma. Si no haces esto, la función se llamara a si misma infinitamente, hasta que el contenido de la pila desborde la capacidad de la memoria del computador provocando un error y finalizando la ejecución.
Ejemplos :
-
Factorial. 4! = 4 * 3!--- 3*2!.... 2*1!..... se incluye una condición de fin cuando se llegue a 1
#include <stdio.h>
int facto (int a)
{
if (a ==1 )
{
return (1);
}
else
return (a*facto(a-1));
void main ( )
{
int n;
scanf ( %d",&n);
printf ( %d", facto (n));
}
-
Potencia.
#include<stdio.h>
int potencia (int base,int exponente)
{
int resul;
if (exponente==0)
{
resul=1;
}
else
{
resul=base*potencia(base,exponente-1);
}
return(resul);
}
void main ()
{
int base,exponente,pot;
scanf("%d",&base);
scanf ("%d",&exponente);
pot=potencia (base,exponente);
printf("%d", pot);
}
TEMA 7
“ARRAYS”
1.DEFINICION DE ARRAY
Muchas aplicaciones requieren el procesado de muchos datos con características comunes. En estas situaciones conviene colocar los datos en un array donde todos ellos comparten el mismo nombre. Los datos individuales del array pueden ser enteros, caracteres, etc., pero todos tienen que ser del mismo tipo y con el mismo tipo de almacenamiento.
Propiedades:
-
Todos los elementos de un array son del mismo tipo.
-
Un array no puede ser leído ni escrito con una única sentencia, sino que se debe acceder a cada dato por separado.
-
El tamaño del array es fijo y definido a priori.
-
Para acceder a un dato dentro del array se utiliza un índice que indica la posición del dato dentro del array.
En C un array no es mas que un conjunto de posiciones continuas de memoria. La dirección mas baja corresponde al primer elemento(esta dirección se encuentra almacenada en el nombre del array) y la mas alta al ultimo elemento
Un array es una estructura de datos formada por un bloque de n elementos todos del mismo tipo y numerados del o al n-1.
Cada uno de los elementos del vector se trata como si fuese una variable independiente del mismo tipo que el del vector.
2. DECLARACIÓN DE UN ARRAY
Los arrays se definen en gran parte como las variables ordinarias, excepto que cada array debe acompañarse de una especificación de su tamaño. Para un array unidimensional el tamaño se especifica con una expresión entera positiva encerrada entre corchetes (ejemplo: int x[10]; Este es un array que se llama x y en el que se pueden guardar 10 números enteros.).
Otra forma de definirlo es usando constantes simbólicas.
Ejemplo
#include <stdio.h>
#define tam 5
void main ()
{
int x[tam];
…..
}
Como variable se daclara:
Void main ()
{
int x[5]={1,2,3,4,5}
…
}
Esto significa que el array llamado x tiene 5 posiciones y los números entre paréntesis son el valor inicial que toma cada posición del array.
Declaracion de un array: TIPO NOMBRE [TAMAÑO]
INT TABLA[5]
N=5
---------------------------------------------
0 1 2 3 4
Se debe tener en cuenta que la declaración de un array no conlleva necesariamente su inicialización, es decir, nadie nos asegura que al declarar el vector todos los elementos valgan 0
Para ello utilizamos un FOR. sin embargo también se pude inicializar un vector al mismo tiempo que se declara(int días[12]={31,28,31,30,31,30,31,31,30,31,30,31})
Una vez definido el array es necesario tener un sistema para referirnos a los elementos individualmente. Esto se realiza mediante índices. Así para referirnos al elemento 4 del array anterior teclearíamos: tabla[4];
Hay que tener presente que debido a que la enumeración empieza por cero, este no es el cuarto elemento sino el quinto.
Ejercicios.
-
Definir un array de 10 posiciones y haremos:
-Inicializarlo a 0.
-Llenarlo con valores introducidos por teclado.
-Mostrar los valores que se han introducido.
#include<stdio.h>
void main()
{
int x[10],i,n;
for (i=0; i<10;i++)
{
x[i]=0;
}
for(i=0;i<10;i++)
{
printf(“dame un numero por favor”);
scanf(“%d”,&n);
x[i]=n;
for(i=0;i<10;i++)
{
printf(“el elemento de la posición %d es %d”,i+1,x[i]);
}
}
}
-
Programa igual que el anterior pero hecho de distinta forma.
#include <stdio.h>
void main ()
{
int x[10],a=0,b=0;
clrscr();
do {
printf("\nPosicion X[ %d ] = %d ",b,x[b]);
b=b+1;
}while (b<10);
do {
x[a]=0;
a=a+1;
}while (a<10);
a=0;
do {
printf("\nDime el valor para la posicion %d del array : " a);
scanf("%d",&x[a]);
a=a+1;
}while (a<10);
printf("\nLos valores introducidos fueron");
b=0;
do {
printf("\n\nPosicion X[ %d ] = %d ",b, x[b]);
b=b+1;
}while (b<10);
getch();
}
-
ahora utilizando un array de tipo char
#include <stdio.h>
void main () {
char x[5];
int a=0,b=0;
clrscr();
for(a=0;a<5;a++)
{
x[a]='0';
}
a=0;
do {
printf("\nDime el valor para la posicion %d del array : ",a);
x[a]=getchar();
a=a+1;
}while (a<5);
printf("\nLos valores introducidos fueron");
b=0;
do {
printf("\n\nPosicion X[ %d ] = %c ",b, x[b]);
b=b+1;
}while (b<5);
getch();
}
-
definir un array "x" donde queremos guardar 10 elementos enteros:
Para declararlo -->
-Primero decimos el tipo de dato que queremos guardar (enteros en este caso)
-Luego el nombre del array
-Luego entre corchetes el numero de elementos.
void main ( ) {
int x [10];
Otra opcion para definirlo es utilizar constantes simbólicas (#define) ,
#define TAM 5
void main ( ) {
int x[TAM];
-
definir un array "x"donde quermos guardar 80 letras;
void main ( ) {
char texto[80]
-
: Queremos declarar un array con 5 casillas para enteros, llamando al array x, dandoles valores iniciales a las caillas.
void main ( ) {
int X [ 5] = { 1,2,3,4,5 }
Los valores serian
X[0]=1
X[1]=2
X[2]=3
X[3]=4
X[4]=5
EJERCICIOS:
-
Tenemos que leer una lista de n números flotantes y calcular la media y
escribir la desviación de cada elemento respecto a la media.
#include <stdio.h>
#define max 100
void main ()
{
float x[max],media,desviacion,suma=0;
int n,cont;
clrscr();
printf("Introduce la cantidad de numeros que vas a introducir");
scanf("%d",&n);
for (cont=0;cont<n;cont++)
{
printf("Dame un numero\n");
scanf ("%f",&x[cont]);
suma=suma+x[cont];
}
media=suma/n;
printf("La media es %f\n",media);
for (cont=0;cont<n;cont++)
{
desviacion=x[cont]-media;
printf("posicion=%d valor=%f
desviacion=%f\n",cont+1,x[cont],desviacion);
}
getch;
}
-
Programa anterior pero con modificaciones.
#include <stdio.h>
#define MAX 100 //defino el array con 100 posiciones
void main()
{
float numeros[MAX],suma=0,media=0,desviacion=0;
int usados,ordinal=1,a=0;
clrscr();
printf("¨Cuantos numeros vas a introducuir? ");
scanf("%d",&usados);
do{
printf("\nDame el %d§ numero: ",ordinal);
scanf("%f",&numeros[a]);
suma=suma+numeros[a];
++a;
++ordinal;
}while(ordinal<=usados);
media=suma/usados;
printf("\n\nLa media es: %5.2f",media); // se puede limitar el tama¤o del numero flotante de
esta forma: por ejemplo si se quiere un flotante de 5 posiciones, reservando 2 de ellas para los de cimales se pone asi: %5.2f
a=0;
ordinal=1;
do
{
desviacion=numeros[a]-media;
printf("\n La posicion %d del array tiene una desviacion de
%5.2f",ordinal,desviacion);
++a;
++ordinal;
}while(ordinal<=usados);
getch();
}
-
Programa que cambie los elementos de un array por los introducidos por el usuario.
#include <stdio.h>
void main()
{
char x[5]={'a','b','c','d','e'};
int i;
char n;
for (i=0;i<5;i++)
{
printf("%c",x[i]);
}
for (i=0;i<5;i++)
{
printf ("letra");
scanf ("%c",&n); /*se puede sustituir por x[i]=getchar();
pero es solo para caracteres*/
x[i]=n;
}
for (i=0;i<5;i++)
{
printf ("%c",x[i]);
}
}
-
Programa que me diga si dos secuencias introducidas por teclado son iguales.
#include <stdio.h>
#define max 100
void main()
{
int longitud,x[max],y[max],i,iguales=1;
do
{
printf("Introduce la longitud de las secuencias\n");
scanf("%d",&longitud);
}while (longitud<=0);
for(i=0;i<longitud;i++)
{
printf("Elemento %d",i+1);
scanf("%d",&x[i]);
}
for(i=0;i<longitud;i++)
{
printf("Elemento %d",i+1);
scanf("%d",&y[i]);
}
for (i=0;i<longitud;i++)
{
if (x[i]!=y[i])
{
iguales=0;
}
}
if (iguales==1)
{
printf("\n Iguales");
}
else
{
printf("\n distintos");
}
}
-
Elaborar un programa que me diga si dos secuencias introducidas por teclado
son iguales (otra forma)
#include <stdio.h>
#define MAX 100
void main(){
int secuencia1[MAX];
int secuencia2[MAX],usados, ordinal=1,a,b,signo;
clrscr();
printf("\nCuantos numeros vas a introducir en las secuencias? ");
scanf("%d",&usados);
a=0;
printf("\n\nPRIMERA SECUENCIA");
delay(500);
do{
printf("\nDame el %d numero: ",ordinal);
scanf("%d",&secuencia1[a]);
++a;
++ordinal;
}while(ordinal<=usados);
b=0;
delay(500);
printf("\n\nSEGUNDA SECUENCIA");
delay (500);
ordinal=1;
do{
printf("\nDame el %d numero: ",ordinal);
scanf("%d",&secuencia2[b]);
++b;
++ordinal;
}while(ordinal<=usados);
a=0;
b=0;
ordinal=1;
do{
if (secuencia1[a]==secuencia2[b])
{
signo=0;
}
if (secuencia1[a]!=secuencia2[b])
{
signo=1;
}
++a;
++b;
++ordinal;
}while(signo==0 && ordinal<=usados);
if (signo==0)
{
printf("\n\nLas secuencias son iguales");
}
if (signo==1)
{
printf("\n\nLas secuencias son diferentes");
}
getch();
}
-
programa que haga una secuencia de numeros enteros, determine si esta
secuencia es creciente,decreciente, o ninguna de las dos
#include <stdio.h>
#define MAX 100
void main ()
{
int n,x[MAX],i,mayor=0,menor=0;
do
{
printf("Introduce la longitud de la secuencia\n");
scanf("%d",&n);
}
while (n<=0);
for (i=0;i<n;i++)
{
printf("Elemento %d\n",i+1);
scanf("%d",&x[i]);
}
for (i=0;i<n-1;i++)
{
if (x[i]>x[i+1])
{
mayor++;
}
else
{
menor++;
}
}
if (mayor==0&&menor!=0)
{
printf("La serie es ascendente\n");
}
else
{
if(mayor!=0&&menor==0)
{
printf("La serie es descendente\n");
}
else
{
printf("La serie no es ascendente ni descendente\n");
}
}
}
-
Elaborar un programa, que dada una secuencia de numeros enteros determine
si esta secuencia es creciente…………..(otra forma)
#include <stdio.h>
#define MAX 100
void main ()
{
int x[MAX], i=0, sec=0, creciente=0, decreciente=0, nada=0;
clrscr();
do
{
printf("\nDime cuantos numeros va a tener la secuencia: ");
scanf("%d", &sec);
}while (sec<=0);
for (i=0;i<sec;i++)
{
printf("Dime un valor para la posici¢n x [ %d ] : ",i);
scanf("%d", &x[i]);
}
for (i=0;i<sec;i++)
{
if (i==sec-1)
{
}
else
{
if (x[i]<x[i+1])
{
creciente=creciente+1;
}
if (x[i]>x[i+1])
{
decreciente=decreciente+1;
}
}
}
if (creciente==sec-1)
{
printf("\nCreciente");
}
else {
nada=nada+1;
}
if (decreciente==sec-1)
{
printf("\nDecreciente");
}
else
{
nada=nada+1;
}
if (nada==2)
{
printf("\nSecuencia Indeterminada");
}
getch();
}
-
Programa que dadas dos secuencias nos diga si existen dos números "f" y "g"
que cumplan que |f-g|<9 La función que hace el valor absoluto es "abs(numero)"
y la biblioteca es #include <stdlib.h>
#include <stdio.h>
#define MAX 100
#include <stdlib.h>
void main()
{
int n,i,x[MAX],y[MAX],j;
do
{
printf ("Introduce la longitud de la secuencia\n");
scanf("%d",&n);
}
while(n<=0);
for(i=0;i<n;i++)
{
printf("Primera secuencia.\nElemento %d\n",i+1);
scanf("%d",&x[i]);
}
for(j=0;j<n;j++)
{
printf("Segunda secuencia.\nElemento %d\n",j+1);
scanf("%d",&y[j]);
}
for (i=0;i<n;i++)
{
for (j=0;j<n;j++)
{
if (abs(x[i]-y[j])<9)
{
printf("Los numeros %d %d cumplen la
funcion\n",x[i],y[j]);
}
}
}
}
-
meto dos secuencias y busca combinaciones que cumplan |f-g|<9
#include <stdlib.h>
#include <stdio.h>
#define MAX 100
void main ()
{
int x[MAX],x2[MAX], numero,sec2=0, sec=0,i=0, u=0,combinaciones=0;
do
{
printf("\nDime cuantos numeros tiene el vector1 : ");
scanf("%d", &sec);
}while (sec<=0);
do
{
printf("\nDime cuantos numeros tiene el vector2 : ");
scanf("%d", &sec2 );
} while (sec<=0);
printf("\nPRIMERA SECUENCIA");
for (i=0;i<sec;i++)
{
printf("\nDime el numero de la posicion x [ %d ] : ", i);
scanf("%d",&x[i]);
}
printf("\nSEGUNDA SECUENCIA");
for (i=0;i<sec2;i++)
{
printf("\nDime el numero de la posicion x2 [ %d ] : ", i);
scanf("%d",&x2[i]);
}
for (i=0;i<sec;i++)
{
for (u=0;u<sec2;u++)
{
if ( (abs(x[i])-(x2[u])) < (9) )
{
combinaciones=combinaciones+1;
printf("\nCombinacion %d, %d - %d = %d ",
combinaciones, x[i], x2[u], abs(x[i]-x2[u]));
}
}
}
if (combinaciones>0)
{
printf("\nHay %d combinaciones", combinaciones);
}
getch();
}
-
Igual que el ejercicio anterior pero de forma que cada vector pueda tener
distinta longitud.
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
void main()
{
int n,i,x[MAX],y[MAX],j,m;
do
{
printf ("Introduce la longitud de la primera secuencia\n");
scanf("%d",&n);
}
while(n<=0);
do
{
printf ("Introduce la longitud de la seguda secuencia\n");
scanf("%d",&m);
}
while (m<=0);
for(i=0;i<n;i++)
{
printf("Primera secuencia.\nElemento %d\n",i+1);
scanf("%d",&x[i]);
}
for(j=0;j<m;j++)
{
printf("Segunda secuencia.\nElemento %d\n",j+1);
scanf("%d",&y[j]);
}
for (i=0;i<n;i++)
{
for (j=0;j<m;j++)
{
if (abs(x[i]-y[j])<9)
{
printf("Los numeros %d %d cumplen la
funcion\n",x[i],y[j]);
}
}
}
}
-
Programa que me diga si dos secuencias crecientes tienen algún elemento
en común.
#include <stdio.h>
#define MAX 100
void main()
{
int n,x[MAX],y[MAX],m,i,j,mayor=0,menor=0,mayor2=0,menor2=0,a,b;
do
{
printf ("Introduce la longitud de la primera secuencia\n");
scanf("%d",&n);
}while(n<=0);
do
{
printf ("Introduce la longitud de la seguda secuencia\n");
scanf("%d",&m);
}while (m<=0);
for(i=0;i<n;i++)
{
printf("Primera secuencia.\nElemento %d\n",i+1);
scanf("%d",&x[i]);
}
for(j=0;j<m;j++)
{
printf("Segunda secuencia.\nElemento %d\n",j+1);
scanf("%d",&y[j]);
}
for (i=0;i<n-1;i++)
{
if (x[i]>x[i+1])
mayor++;
else
menor++;
}
if (mayor==0&&menor!=0)
{
printf("La primera serie es creciente\n");
}
else
{
if(mayor!=0&&menor==0)
{
printf("La primera serie es decreciente\n");
}
else
{
printf("La primera serie no es creciente ni
decreciente\n");
}
}
for (j=0;j<m-1;j++)
{
if (y[j]>y[j+1])
{
mayor2++;
}
else
{
menor2++;
}
}
if (mayor2==0&&menor2!=0)
{
printf("La segunda serie es creciente\n");
}
else
{
if(mayor2!=0&&menor2==0)
{
printf("La segunda serie es decreciente\n");
}
else
{
printf("La segunda serie no es creciente ni
decreciente\n");
}
}
if((mayor==0)&&(mayor2==0))
{
for (a=0;a<n;a++)
{
for (b=0;b<m;b++)
{
if(x[a]==y[b])
{
printf("Entre la primera serie y la segunda
es comun el valor %d",x[a]);
}
}
}
}
else
{
printf("Las dos series no tienen ningun valor en comun.\n");
}
}
-
Dos secuencias crecientes , ver si tienen algun elemento en comun.
#include <stdio.h>
#define MAX 100
void main ()
{
int x[MAX],x2[MAX], i=0, sec, creciente=1, decreciente=1, salida=0;
int u=0, sec2, creciente2=1,combinaciones=0;
clrscr();
do
{
printf("\nDime cuantos numeros va a tener la secuencia1: ");
scanf("%d", &sec);
}while (sec<=0);
for (i=0;i<sec;i++)
{
printf("\nDime un valor para la posicion x [ %d ] : ",i);
scanf("%d", &x[i]);
if (i==10||i==20||i==30)
{
printf("Pulsa cualquier tecla para continuar...");
clrscr();
}
}
for (i=0;i<sec-1;i++)
{
if (x[i]<x[i+1])
else
{
creciente=0;
i=sec-1;
}
}
if (creciente==1)
{
printf("\nLa secuencia 1 es Creciente\n\n");
}
else
{
for (i=0;i<sec-1;i++)
{
if (x[i]>x[i+1])
{
}
else
{
decreciente=0;
i=sec-1;
}
}
if (decreciente==1)
{
printf("\nLa secuencia 1 es Decreciente");
}
else
{
printf("\nLa secuencia 1 es indefinida");
}
}
decreciente=1;
getch();
clrscr();
do {
printf("\nDime cuantos numeros va a tener la secuencia2: ");
scanf("%d", &sec2);
}while (sec2<=0);
for (i=0;i<sec2;i++)
{
printf("\nDime un valor para la opsici¢n x2 [ %d ] : ",i);
scanf("%d", &x2[i]);
if (i==10||i==22||i==33)
{
printf("\nPulsa cualquier tecla para continuar");
clrscr();
}
}
for (i=0;i<sec2-1;i++)
{
if (x2[i]<x2[i+1])
{
}
else
{
creciente2=0;
i=sec2-1;
}
}
if (creciente2==1)
{
printf("\nLa secuencia 2 es Creciente\n\n");
}
else
{
for (i=0;i<sec2-1;i++)
{
if (x2[i]>x2[i+1])
{
}
else
{
decreciente=0;
i=sec2-1;
}
}
if (decreciente==1)
{
printf("\nLa secuencia 2 es Decreciente\n");
}
else {
printf("\nLa secuencia 2 es indefinida\n");
}
}
printf("\nPulse cualquier tecla para continuar ....");
getch();
if (creciente==1&&creciente2==1)
{
clrscr();
printf("\n *******: COMBINACIONES :***** \n");
for (i=0; i<sec; i++)
{
for (u=0;u<sec2;u++)
{
if (x2[i]==x2[u])
{
printf("\nLa posici¢n X [ %d ] de la
secuencia 1 vale %d \n\ry la posici¢n x2 [
%d ] de la secuencia 2 vale %d\n\n\n",
i,x2[i],u, x2[u]);
combinaciones=combinaciones+1;
if(combinaciones==4||combinaciones==8
||combinaciones==12)
{
printf("Pulse cualquier tecla para
continuar....");
getch();
clrscr();
}
}
}
}
if (combinaciones==0)
{
printf("\nNo hay combinaciones");
}
}
else
{
printf("\n\nAlguna de las dos no es creciente");
}
if (combinaciones>0)
{
printf("\n\nEL NUMERO TOTAL DE COMBINACIONES ES %d",
combinaciones);
}
getch();
}
3. PROCESAMIENTO DE UN ARRAY
No se puede asignar un vector a otro
Tabla1=tabla2
Tabla1[1]=tabla2[1]
En C no se permiten operaciones que impliquen arrays completos. Si a y b son dos arrays similares (guardan el mismo tipo de datos y con el mismo tamaño) las operaciones de asignación, de comparación deben realizarse elemento por elemento. Esto se hace en un bucle donde en cada paso del bucle comparamos un elemento. Tenemos que repetir este bucle tantas veces como el tamaño del array.
4.OPERACIONES CON ARRAYS
-
Metodos de ordenacion de los elementos de un vector
1-METODO DE LA BURBUJA:
# include <stdio.h>
#define MAX 8
int tabla[MAX]={4,7,0,3,-1,8,2,-8};
void main ( )
{
int i, j ,temp ;
for (i=1;i<MAX; i++)
{
for (j=MAX-1;j>=i;j--)
{
if ( tabla[j]<tabla[j-1])
{
temp=tabla[j];
tabla[j]=tabla[j-1];
tabla[j-1]=temp;
}
}
}
printf ( " \n Ordendado ");
for ( j = 0 ; j < MAX ; j++ )
printf("\n Elemento %d ; %d", j+1, tabla [ j ] );
getch();
}
2.-SELECCIÓN DIRECTA
#include <stdio.h>
#define MAX 4
int tabla [MAX]= { 4,3,5,2 } ;
void main ()
{
int i,j,k,temp;
for ( k = 0 , k < MAX - 1 ; k ++ )
{
i = k ;
temp = tabla [ k ];
for ( j = k+1 ; j < MAX ; j++ )
{
if ( tabla [ j ] < temp )
{
i = j ;
temp = tabla [ i ] ;
}
}
tabla [ i ] = tabla [ k ] ;
tabla [ k ] = temp ;
}
printf ( " \n Ordenado ");
for (j = 0 ; j < MAX ; j ++ )
{
printf ( " \n Elemnto %d ; %d ", j + 1 , tabla [ j ] );
}
}
3.-INSERCCIÓN DIRECTA
#include <stdio.h>
#define MAX 4
int tabla[MAX] = { 4,3,5,2};
void main ( ) {
int j,k,temp;
for (j=1; j < MAX ; j++ ) {
temap = tabla [ j ] ;
k = k - 1;
while (tabla [ k ] > temp && k > 0 )
{
tabla [k+1] = tabla [k];
k = k-1 ;
}
if ( tabla [k] > temp ) {
tabla [ k+1] = tabla [ k ] ;
k = k-1;
}
else {
tabla [k+1] = temp;}
printf (" \n Ordenado ");
for ( j =0; j< MAX; j++) {
printf("\n Elemento %d ; %d ", j + 1, tabla [ j ] );
}
}
5. PASO DE ARRAYS A FUNCIONES
El nombre de un Array se puede usar como argumento de una función permitiendo que el array completo sea pasado a la función.
Para pasar un Array, su nombre debe aparecer solo, sin corchetes ni índices, como un argumento actual dentro de la llamada a la función. El correspondiente argumento formal se pone: el nombre del Array con dos corchetes vacíos.
El tamaño no se especifica dentro de la declaración formal.
“para pasar un array a una función se le pasa el nombre del array, es decir se pasa la dirección del comienzo del array. Esto significa que todas las operaciones que se realizan sobre el array mientras esta dentro de la función afectan al array fuera de la función.”
-
Vamos a declarar un array de cinco posiciones enteras y los vamos a llenar con valores a través de una función e imprimirles a través de otra función.
#include <stdio.h>
void llena( int x[])
{
int i;
for(i=0;i<5;i++)
}
printf("elemento;");
scanf("%d",&x[i]);
}
return;
}
void imprime(int x[])
{
int i;
printf("elemento%d valor%d\n",i+1,x[i]);
}
return;
}
void main()
{
int x[5];
llena(x);
imprime(x);}
-
Declarar un array de N posiciones, y pasar la información a las funciones.
#include <stdio.h>
#define MAX 100
void llena (int x[ ], int h )
{
int i ;
clrscr();
for (i=0; i<h;i++) {
printf ( "\nElementos: " );
scanf ( "%d", &x[i]);
}
return ;
}
void imprime (int x [ ], int h )
{
int i ;
for (i=0;i<h;i++)
{
printf ("\nElemento %d valor %d ",i+1,x[i]);
}
return;
}
void main ()
{
int x[MAX], numero;
do
{
printf("\nTamaño");
scanf("%d", &numero);
}while (numero<=0);
llena ( x,numero );
imprime ( x,numero );
getch();
}
-
Elavorar un programa, que dada una secuencia de numeros enteros determine
si esta secuencia es creciente, decreciente, o ninguna de las dos.El main solo imprime los resultados y tiene que haber:
funcion para llenar el array
funcion para ver si es creciente
funcion para ver si es decreciente
#include <stdio.h>
#define MAX 100
int llenar ( int x[] )
{
int sec, i=0;
do
{
printf("\nDime cuantos numeros va a tener la secuencia: ");
scanf("%d", &sec);
}while (sec<=0);
for (i=0;i<sec;i++)
{
printf("Dime un valor para la posicion x [ %d ] : ",i);
scanf("%d", &x[i]);
}
return(sec);
}
int creciente (int x[],int sec)
{
int i=0,signo=1;
for (i=0;i<sec-1;i++)
{
if (x[i]<x[i+1])
{
}
else
{
signo=0;
}
}
return(signo);
}
int decreciente (int x[], int sec )
{
int i=0, signo=1;
for (i=0;i<sec-1;i++)
{
if (x[i]>x[i+1])
{
}
else
{
signo=0;
}
}
return(signo);
}
void main ()
{
int x[MAX], tamano, nada=0,cre=0,dec=0;
tamano=llenar(x);
cre=creciente(x,tamano);
if (cre==1)
{
printf("\nLa secuencia es creciente");
}
else
{
nada=nada+1;
}
dec=decreciente(x,tamano);
if (dec==1)
{
printf("\nLa secuencia es decreciente");
}
else
{
nada=nada+1;
}
if (nada==2)
{
printf("\nLa secuencia es indefinida");
}
getch();
}
-
programa que haga una secuencia de números enteros, determine si esta
secuencia es creciente, decreciente, o ninguna de las dos.
#include <stdio.h>
#define MAX 100
void posicion(int x[],int m)
{
int i;
for (i=0;i<m;i++)
{
printf("Elemento %d\n",i+1);
scanf("%d",&x[i]);
}
return;
}
void crec_decrec (int x[],int m)
{
int i,mayor=0,menor=0;
for (i=0;i<m-1;i++)
{
if (x[i]>x[i+1])
{
mayor++;
}
else
{
menor++;
}
}
if (mayor==0&&menor!=0)
{
printf("La serie es ascendente\n");
}
else
{
if(mayor!=0&&menor==0)
{
printf("La serie es descendente\n");
}
else
{
printf("La serie no es ascendente ni descendente\n");
}
}
return;
}
void main ()
{
int n,x[MAX];
do
{
printf("Introduce la longitud de la secuencia\n");
scanf("%d",&n);
}while (n<=0);
posicion(x,n);
crec_decrec(x,n);
}
-
Programa que me diga si dos secuencias introducidas por teclado son iguales.
#include <stdio.h>
#define max 100
int longi ()
{
int longitud;
do
{
printf("Introduce la longitud de las secuencias\n");
scanf("%d",&longitud);
}while (longitud<=0);
return (longitud);
}
void secuencias (int x[],int y[],int n)
{
int i;
for(i=0;i<n;i++)
{
printf("Primera secuencia.Elemento %d",i+1);
scanf("%d",&x[i]);
}
for(i=0;i<n;i++)
{
printf("Segunda secuencia.Elemento %d",i+1);
scanf("%d",&y[i]);
}
return;
}
void igual_distinto (int x[],int y[],int n)
{
int i,iguales=1;
for (i=0;i<n;i++)
{
if (x[i]!=y[i])
{
iguales=0;
}
}
if (iguales==1)
{
printf("\n Iguales");
}
else
{
printf("\n distintos");
}
return;
}
void main()
{
int x[max],y[max],tamano;
tamano=longi();
secuencias(x,y,tamano);
igual_distinto(x,y,tamano);
}
-
programa que diga si dos secuencias introducidas por teclado son iguales, pedimos la primera, luego la segunda y luego comparamos uno a uno.(son enteros)
#include <stdio.h>
#define MAX 100
void main ()
{
int x[MAX], x2[MAX],cont1,cont2,i,signo=0;
do
{
printf("\nDime cuantos numeros tienen las secuencias: ");
scanf("%d",&cont1);
}while (cont1<=0);
printf("\nPRIMERA SECUENCIA");
for (i=0;i<cont1;i++)
{
printf("\nDime el valor: ");
scanf("%d",&x[i]);
}
printf("\nSEGUNDA SECUENCIA");
for (i=0;i<cont1;i++)
{
printf("\nDime el valor: ");
scanf("%d",&x2[i]);
}
for (i=0;i<cont1;i++)
{
if (x[i]==x2[i])
{
signo=signo+1;
}
}
if (signo==cont1)
{
printf("\nIGUALES");
}
else
{
printf("\nDISTINTAS");
}
getch();
}
-
Programa que me diga si dos secuencias crecientes tienen algún elemento en común.
#include <stdio.h>
#define MAX 100
int secuencia ()
{
int n;
do
{
printf ("Introduce la longitud de la secuencia\n");
scanf("%d",&n);
}while(n<=0);
return (n);
}
void elementos(int z[],int n)
{
int i;
for(i=0;i<n;i++)
{
printf("Elemento %d\n",i+1);
scanf("%d",&z[i]);
}
return;
}
int crec_decrec(int z[],int n)
{
int i,mayor=0,menor=0;
for (i=0;i<n-1;i++)
{
if (z[i]>z[i+1])
{
mayor++;
}
else
{
menor++;
}
}
if (mayor==0&&menor!=0)
{
return (1); /*creciente*/
}
else
{
if(mayor!=0&&menor==0)
{
return (2); /*decreciente*/
}
else
{
return (3); /*Nada*/
}
}
}
void comparar(int x[],int y[],int n,int m)
{
int a,b;
for (a=0;a<n;a++)
{
for (b=0;b<m;b++)
{
if(x[a]==y[b])
{
printf("Entre la primera serie y la segunda es
comun el valor %d\n",x[a]);
}
}
}
return;
}
void main()
{
int longitud1,longitud2,x[MAX],y[MAX],resultado1=0,resultado2=0;
longitud1=secuencia();
longitud2=secuencia();
elementos (x,longitud1);
elementos (y,longitud2);
resultado1=crec_decrec(x,longitud1);
resultado2=crec_decrec(y,longitud2);
if (resultado1==1&&resultado2==1)
{
comparar (x,y,longitud1,longitud2);
}
}
-
Programa que te encuentre elementos comunes en dos secuencias de numeros enteros (otra forma)
#include<stdio.h>
#define MAX 100
int n;
void llena(int h[])
{
int i;
for(i=0;i<n;i++)
{
printf("elemento %d\n",i+1);
scanf("%d",&h[i]);
}
return;
}
int creciente(int x[])
{
int i,crec=1;
for(i=0;i<(n-1);i++){
if(x[i]>x[i+1])
crec=0;
}
return(crec);
}
int comun(int h[],int f[]){
int i,j,comunes=0;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(h[i]==f[j])
comunes=1;
}
}
return(comunes);
}
void main()
{
int sec1[MAX],sec2[MAX];
do{
printf("\ndame el tamaño\n");
scanf("%d",&n);
}while(n<=0);
llena(sec1);
llena(sec2);
if(creciente(sec1) && creciente(sec2)){
if(comun(sec1,sec2))
printf("hay comunes\n");
else
printf("no hay comunes\n");
}
else
printf("las dos no son crecientes\n");
}
6.ARRAYS MULTIDIMENSIONALES
hasta ahora hemos visto los arrays de una sola dimension, es decir con un solo indice, pero los arrays pueden tener dos o mas dimensiones. Para recorrer arrays de mas de dos dimensiones es necesario anidar bucles tantos como dimensiones tenga el array. Los arrays de mas de dos dimensiones no se utilizan mucho debido a la cantidad de memoria que es necesaria para mantenerlos
Se definen de la misma forma que los Arrays unidimensionales, excepto que se requiere un par separado de corchetes para cada índice.
Ejemplo: INT X[M][N]; m=filas n=columnas
0 1 2 3
Cuando utilizamos los arrays mutidimensionales como argumentos formales en una función, el número de filas no se pasa. Ejemplo: int función (int x[ ][n] ) y en el punto de llamada a la funcion no varia nada, sigue siendo asi: NOMBRE DE LA FUNCION (NOBRE DEL ARRAY) .
EJERCICIOS:
-
Declarar dos matrices de 5 filas y 4 columnas. Llenarlas de elementos
enteros y sacar por pantalla el resultado de sumar las dos matrices.
#include <stdio.h>
void main()
{
int x[5][4],y[5][4],z[5][4],i,j,cont=0,cont2=0;
for (i=0;i<5;i++)
{
for(j=0;j<4;j++)
{
cont++;
printf ("Primera matriz.Valor %d\n",cont);
scanf ("%d",&x[i][j]);
}
}
for (i=0;i<5;i++)
{
for(j=0;j<4;j++)
{
cont2++;
printf ("Segunda matriz.Valor %d\n",cont2);
scanf ("%d",&y[i][j]);
}
}
for (i=0;i<5;i++)
{
for(j=0;j<4;j++)
{
z[i][j]=x[i][j]+y[i][j];
printf(" %d ",z[i][j]);
}
printf("\n");
}
}
-
Ejercicio anterior pero realizado con funciones.
#include<stdio.h>
void llena (int x[][4])
{
int i,j;
for (i=0;i<5;i++)
{
for(j=0;j<4;j++)
{
printf("Introduce valores");
scanf("%d",&x[i][j]);
}
}
return;
}
void suma (int a[][4],int b[][4],int c[][4])
{
int i,j;
for (i=0;i<5;i++)
{
for (j=0;j<4;j++)
{
c[i][j]=a[i][j]+b[i][j];
}
}
return;
}
void imprime (int h[][4])
{
int i,j;
for(i=0;i<5;i++)
{
for (j=0;j<4;j++)
{
printf("%d",h[i][j]);
}
}
return;
}
void main()
{
int n1[5][4],n2[5][4],res[5][4];
llena(n1);
llena(n2);
suma(n1,n2,res);
imprime(res);
}
-
Programa que lea una matriz de "M" filas y "N" columnas y escriba el resultado de restar a cada elemento, la media aritmética de la media de su fila y de su columna.
#include<stdio.h>
#define MAXFILA 100
#define MAXCOL 100
void main ()
{
int x[MAXFILA][MAXCOL], i, j, filas,columnas, n, m;
float mediafila[MAXFILA], mediacolumna[MAXCOL],
float sumafila=0, sumacolumna=0,resultado=0;
clrscr ();
do
{
printf ("¨Cuantas filas y columnas vas a introducir en la
Matriz?.\n");
scanf ("%d %d", &n, &m);
} while (n<=0 || m<=0);
printf ("Introduzca los numeros deseados.\n");
for (i=0; i<n; i++)
{
sumafila=0;
for (j=0; j<m; j++)
{
printf ("Situacion: linea %d- columna %d.\n", i+1,j+1);
scanf ("%d", &x[i][j]);
sumafila+=x[i][j];
}
mediafila[i]=sumafila/m;
}
for (i=0; i<m; i++)
{
sumacolumna=0;
for (j=0; j<n; j++)
{
sumacolumna+=x[j][i];
}
mediacolumna[i]=sumacolumna/n;
}
printf ("El resultado es:\n");
for (i=0; i<n; i++)
{
for (j=0; j<m; j++)
{
resultado=x[i][j]-((mediafila[i]+mediacolumna[j]/2));
printf (“%f “, resultado);
}
printf (“\n”);
}
getch ();
}
-
Ejercicio anterior resuelto con funciones.
#include<stdio.h>
#define maxfil 100
#define maxcol 100
void llena (int a[][maxcol],int n,int m)
{
int cont=0,i,j;
for (i=0;i<n;i++)
{
for (j=0;j<m;j++)
{
cont++;
printf("Introduce valor %d\n",cont);
scanf("%d",&a[i][j]);
}
}
}
float mediafila (int y[][maxcol],int n,int w)
{
int i,suma;
float media;
for (i=0;i<n;i++)
{
suma=suma+y[w][i];
}
media=suma/n;
return (media);
}
float mediacol (int y[][maxcol],int n,int w)
{
int i,suma=0;
float media;
for (i=0;i<n;i++)
{
suma=suma+y[i][w];
}
media=suma/n;
return (media);
}
void main()
{
int longfil,longcol,x[maxfil][maxcol],f,z;
float media1,media2,mediatotal,resta;
do
{
printf("Introduce la longitud de las filas\n");
scanf("%d",&longfil);
}while (longfil<=0);
do
{
printf("Introduce la longitud de las columnas\n");
scanf("%d",&longcol);
}while (longcol<=0);
llena(x,longfil,longcol);
for (z=0;z<longfil;z++)
{
for (f=0;f<longcol;f++)
{
media1=mediafila (x,longfil,f);
printf("media 1=%f\n",media1);
media2=mediacol (x,longcol,f);
printf("media 2=%f\n",media2);
mediatotal=(media1+media2)/2;
resta=x[z][f]-mediatotal;
printf("%f",resta);
}
printf("\n");
}
}
-
leer una matriz de f filas y c columnas, y que escriba el resultado de
restar a cada elemento la media aritmetica de la media de su fila y su
columna (otra forma)
#include <stdio.h>
#define FIL 100
#define COL 100
void llenar (float x[][COL],int col ,int fila)
{
int i,u;
for (i=0;i<fila;i++)
{
for (u=0;u<col;u++)
{
printf("\nDime un numero para la %d fila %d columna: ",
i,u);
scanf("%f", &x[i][u]);
}
}
return;
}
void mediafil (float x[][COL], int col, int fila, float mediafila[FIL])
{
int i,u;
float suma=0;
for (i=0;i<fila;i++)
{
for (u=0;u<col;u++)
{
suma=suma+x[i][u]; //calcular la media fila
}
mediafila[i]=suma/col;
// printf(" %f",mediafila[i]);
suma=0;
}
return;
}
void mediacol (float x[][COL], int col, int fila, float mediacolum[COL]) {
int i,u;
float suma=0;
for (i=0;i<col;i++)
{
for (u=0;u<fila;u++)
{
suma=suma+x[u][i];
}
mediacolum[i]=suma/fila;
// printf("%f",mediacolum);
suma=0;
}
return;
}
void res (float x[][COL], int col, int fil, float mediaf[], float
mediac[], float resu[][COL])
{
int i,u;
float medias=0;
for (i=0;i<fil;i++)
{
for (u=0;u<col;u++)
{
medias=(mediaf[i]+mediac[u])/2;
resu[i][u]=x[i][u]-medias;
//printf(" %f", resu[i][u]);
medias=0;
}
printf("\n");
}
return;
}
void imprime (float resul[][COL], int fil, int col) {
int i,u;
for (i=0;i<fil;i++)
{
for (u=0;u<col;u++)
{
printf(" %f", resul[i][u]);
}
printf("\n");
}
return;
}
void main ()
{
float x[FIL][COL];
int filas=0, columnas=0;
float mediafila[FIL],mediacolum[COL],resultado[FIL][COL];
do {
printf("\nDime cuantas filas tiene la matriz: ");
scanf("%d", &filas);
} while (filas<=0);
do {
printf("\nDime cuantas columnas tiene la matriz: ");
scanf("%d", &columnas);
} while (columnas<=0);
llenar (x,columnas,filas);
mediafil (x,columnas,filas,mediafila);
mediacol (x,columnas,filas,mediacolum);
res (x,columnas,filas,mediafila,mediacolum,resultado);
imprime (resultado, filas, columnas);
getch();
}
OTROS PROGRAMAS DE ARRAYS
-
Programa que pase a decimal un numero binario. La funcion que hace la
potencia es pow(base,exponente) y la biblioteca es math.h
#include<stdio.h>
#include<math.h>
#define max 100
void main ()
{
int numero,longitud,x[max],i,suma=0,potencia=0;
do
{
printf("Introduce la longitud del n£mero binario.\n");
scanf("%d",&longitud);
}while (longitud<=0);
for (i=longitud-1;i>=0;i--)
{
printf("Introduce el digito del numero binario.\n");
scanf("%d",&x[i]);
if (x[i]<0||x[i]>1)
{
printf("Numero incorrecto.Introduce 0 ¢ 1.\n");
scanf("%d",&x[i]);
}
}
for (i=0;i<longitud;i++)
{
if (x[i]==1)
{
potencia=pow (2,i);
suma=suma+potencia;
}
}
printf("El numero binario es %d",suma);
}
-
Programa que compruebe si un numero introducido por teclado este contenido
en un vector de números enteros.
#include<stdio.h>
#define max 100
void main()
{
int longitud,i,x[max],cont=0,num,cont1=0;
do
{
printf("Introduce la longitud del vector\n");
scanf("%d",&longitud);
}while (longitud<=0);
for (i=0;i<longitud;i++)
{
cont++;
printf("Introduce un valores.Valor %d\n",cont);
scanf("%d",&x[i]);
}
printf("Introduce un n£mero aleatorio.\n");
scanf("%d",&num);
for(i=0;i<longitud;i++)
{
if (x[i]==num)
{
cont1 ++;
}
}
if (cont1==0)
{
printf("El numero introducido NO esta en el vector.\n");
}
else
{
printf("El n£mero introducido SI esta en el vector.\n");
}
}
-
programa que compruebe si un elemento introducido por teclado esta o no
en un array entero (con funciones)
#include <stdio.h>
#define MAX 100
void llenar ( int array [], int n)
{
int i;
for (i=0;i<n;i++)
{
printf("\nDime el numero de la posicion %d: ", i);
scanf("%d", &array[i]);
}
return;
}
void buscar (int array[], int n, int numero)
{
int i,signo=1;
for (i=0;i<n;i++)
{
if (array[i]==numero)
{
printf("El numero %d esta en la posici¢n %d del
array\n", numero, i);
i=n;
signo=0;
}
}
if (signo==1){
printf("\nEl numero no esta ");
array[n]=numero;
n=n+1;
}
return;
}
void main()
{
int array[MAX],n, numero, i;
do {
printf("\nDime el n£mero de cifras del array: ");
scanf("%d", &n);
} while (n<=0);
llenar (array, n);
printf("\nDime un numero para ver si esta en el array: ");
scanf("%d", &numero);
buscar (array, n, numero);
for (i=0;i<n+1;i++)
{
printf(" %d", array[i]);
}
getch();
}
-
Programa que cuente el numero de palabras que terminan en "s" en un texto
e imprima la palabra.
#include <stdio.h>
#define MAX 1000
#include <string.h>
void main()
{
int i,cont=0,contador=0,longitud,posicion,principio;
char texto[MAX];
printf ("Introduce el texto\n");
gets(texto);
longitud=strlen(texto);
texto[longitud]=' ';
texto[longitud+1]='\0';
for (i=0;i<longitud+1;i++)
{
if (texto[i]==' ')
{
if (texto[i-1]=='s')
{
contador++;
if(cont==0)
{
for (posicion=0;posicion<i;posicion++)
{
printf("%c",texto[posicion]);
}
printf("\n");
}
else
{
for(posicion=principio;posicion<i;posicion++)
{
printf("%c",texto[posicion]);
}
printf("\n");
}
}
principio=i+1;
}
cont++;
}
printf("En el texto hay %d palabras que terminan en s\n",contador);
}
-
programa que te pasa los numeros romanos a numeros actuales.
#include<stdio.h>
#include<conio.h>
void main()
{
int i,x,c,cont,f;
char linea[100];
clrscr();
printf("\n Escribeme un numero romano:");
i=0;
do{
linea[i]=toupper(getchar());
i++;
}while(linea[i-1]!='\n' && i<100);
for(c=0;c<i;c++)
{
printf("\n %c",linea[c]);
f=c;
}
cont=0;
for(c=0;c<f;c++)
{
switch(linea[c])
{
case 'M':
cont=cont+1000;
if(linea[c-1]=='C')
{
cont=cont-200;
}
break;
case 'D':
cont=cont+500;
if(linea[c-1]=='C')
{
cont=cont-200;
}
break;
case 'C':
cont=cont+100;
if(linea[c-1]=='X')
{
cont=cont-20;
}
break;
case 'L':
cont=cont+50;
if(linea[c-1]=='X')
{
cont=cont-20;
}
break;
case 'X':
cont=cont+10;
if(linea[c-1]=='I')
{
cont=cont-2;
}
break;
case 'V':
cont=cont+5;
if(linea[c-1]=='I')
{
cont=cont-2;
}
break;
case 'I':
cont=cont+1;
break;
}//fin swith
}//fin for
printf("\n el numero es %i",cont);
}
-
Un programa que le quite los espacios al texto que introduzcamos por teclado
#include <stdio.h>
#include <string.h>
#define MAX 1000
void main ()
{
char conespacios[MAX], sinespacios[MAX];
int caracteres=0,i,u=0;
printf("\n Escribe un texto : \n");
gets (conespacios);
caracteres=strlen(conespacios);
conespacios[caracteres]='\0';
for (i=0;i<caracteres;i++)
{
if (conespacios[i]!=' ')
{
sinespacios[u]=conespacios[i];
u=u+1;
}
}
sinespacios[u]='\0';
printf("\n%s\n",sinespacios);
printf("\n%s\n",conespacios);
getch();
}
-
programa que cambie el texto en minuscula a mayusculas.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 1000
void main ()
{
char array[MAX],resultado[MAX];
int i,caracteres=0;
printf("\nDime una frase en minusculas: \n\n ");
gets(array);
caracteres=strlen(array);
array[caracteres]='\0';
for (i=0;i<caracteres;i++) {
resultado[i]=toupper(array[i]);
}
// resultado[caracteres]='\0';
for (i=0;i<caracteres;i++) {
printf("%c", resultado[i]);
}
getch();
}
-
programa en el que se pida una secuencia de numeros enteros , y se calcule la media despues pedimos un elemento y miramos a ver si esta en el vector, si esta tenemos
que decir en que posicion esta , y sino esta lo insertamos en la posicion
que le corresponda
#include <stdio.h>
#define MAX 100
void llenar (int array[], int numero )
{
int i;
for (i=0;i<numero;i++)
{
printf("\nDime un numero para la posici¢n Array [ %d ] ; ", i);
scanf("%d",&array[i]);
}
return;
}
float suma (int array[], int numero )
{
int i,contador=0;
float media=0,acumulador=0;
for (i=0;i<numero;i++)
{
acumulador=acumulador+array[i];
contador=contador+1;
}
media=acumulador/contador;
return(media);
}
int buscar (int array[], int numero, int buscar )
{
int i,signo=1;
for (i=0;i<numero;i++)
{
if (array[i]==buscar)
{
printf("\nEl numero %d es el elemento %d del array\n",
buscar, i+1);
signo=0;
}
}
if (signo==1) printf("\n\nEl numero no esta ");
return(signo);
}
void ordenar (int array[], int numero)
{
int j,k=0,temp;
for (j=1;j<numero;j++)
{
temp = array[j] ;
k=j-1;
while (array[ k ] > temp && k > 0 )
{
array[k+1] = array[k];
k=k-1;
}
if ( array[k] > temp )
{
array[k+1] = array[k] ;
array[k]=temp;
}
else
{
array[k+1] = temp;
}
}
printf (" \n Ordenado ");
for ( j=0; j<numero; j++)
{
printf("\n Elemento %d ; %d ", j+1,array[j] );
}
return;
}
void insertar ( int array[], int numero, int inst )
{
int i,x;
for (i=0;i<numero;i++)
{
if (inst<=array[i])
{
for (x=numero+1;x>=i;x--)
{
array[x]=array[x-1];
}
array[i]=inst;
i=numero;
}
}
return;
}
void main ()
{
int sec[MAX], nsec=0,numero=0,signo=0;
float media=0;
do
{
printf("\nDime cuantos n£meros tiene la secuencia : ");
scanf("%d", &nsec);
} while ( nsec <= 0 );
llenar(sec,nsec);
media=suma(sec,nsec);
printf("\nLa Media es %f ", media);
printf("\n\nDime el numero que quieres buscar en el array : ");
scanf("%d", &numero);
ordenar (sec,nsec);
signo=buscar ( sec,nsec,numero);
if (signo==1)
{
insertar(sec,nsec,numero);
}
ordenar (sec,nsec+1);
getch();
}
-
Se denomina punto de silla m(filas)*n(columnas) a aquellos valores que son
simultaneamente maximo de su fila y minimo de la columna.Queremos ver los puntos de silla.
#include <stdio.h>
#include<conio.h>
#define FIL 100
#define COL 100
void main ()
{
inti,matriz[FIL][COL],fila,columna,j,maxf[FIL],minc[COL],maximo=0;
int minimo=0;
clrscr();
printf("tama¤o?:");
scanf("%d %d",&fila,&columna);
for(i=0;i<fila;i++)
{
for(j=0;j<columna;j++)
{
printf("valor %d:\n",j+1);
scanf("%d",&matriz[i][j]);
}
}
for (i=0;i<fila;i++)
{
maximo=0;
for(j=0;j<columna;j++)
{
if (matriz[i][j]>=maximo)
{
maximo=matriz[i][j];
}
maxf[i]=maximo;
}
for(i=0;i<columna;i++)
{
minimo=10000;
for(j=0;j<fila;j++)
{
if(matriz[j][i]<=minimo)
minimo=matriz[j][i];
}
minc[i]=minimo;
}
for(i=0;i<fila;i++)
{
for(j=0;j<columna;j++)
{
if(matriz[i][j]==minc[j]&&matriz[i][j]==minc[j])
printf("El n§ %d de la fila %dy la columna %d es
un punto de silla",matriz[i][j],i+1,j+1);
}
}
}
}
TEMA 8
“PUNTEROS”
PUNTEROS.CONCEPTOS BÁSICOS
DEFINICION: Una variable de tipo puntero es un tipo de dato cuyo valor es la dirección de almacenamiento de otro tipo de dato(variable) dentro de la memoria del ordenador, es decir una variable que contiene la dirección de otra variable.
Dentro de la memoria, cada dato ocupa una o más celdas contiguas. El número de celdas requeridas para almacenar un dato dependerá del tipo de dato con el que tratamos. (ya que no ocupa lo mismo un entero que un carácter)
Supongamos que V es una variable que representa un determinado dato. Cuando lo declaramos el compilador reserva memoria para ese dato. El dato puede ser accedido si conocemos la dirección de la primera celda de memoria que ocupa.(Para acceder al contenido de una casilla de memoria se puede hacer de dos formas, o conociendo el nombre de la variable, o la posición que ocupa).
Esa dirección puede ser determinada mediante la expresión &V, donde & es un operador de dirección que proporciona la dirección del operante. Esa dirección se le puede asignar a otra variable de la siguiente forma: pv=&V
Ahora la variable pv contiene la dirección de V, no su valor, y es una variable de tipo puntero.
Ahora el dato que contiene V puede ser accedido de dos formas:
-
La primera es la utilizada hasta ahora: utilizando el nombre de la variable.
-
Accediendo al contenido de la dirección que guarda el puntero: *variable. El * se llama operador indirección.
Por lo tanto *variable y variable es lo mismo es decir, v=*pv.
En definitiva esto se resume en dos cosas:
-
"Pv" por si sólo almacena una dirección (pv=&v),
-
"v" también puede ser accedida como el contenido que guardo en esa dirección
( v contiene lo mismo que *pv ).
EJEMPLOS:
#include <stdio.h>
void main ()
{
int u=3;
int v;
int *pu; //puntero que apunta a u
int *pv; //puntero que apunta a v
pu= &u;
v=*pu;
pv=&v;
printf("\n u=%d &u=%X pu=%X *pu=%d", u, &u,pu,*pu);
printf("\n \n v=%d &v=%X pv=%X *pv=%d ", v,&v,pv,*pv);
}
solucion u=3 &u=fff4 pu=fff4 *pu=3 v=3 &v=fff2 pv=fff2 *pv=3
#include <stdio.h>
void main ()
{
int u1,u2;
int v=3;
int *pv;
u1=2*(v+5);
pv=&v;
u2=2*(*pv+5);
printf("\nu1=%d u2=%d", u1,u2);
}
solucion u1=16 u2=16
#include <stdio.h>
void main()
{
int v=3;
int *pv;
pv=&v;
printf("\n *pv=%d v=%d ",*pv,v);
*pv=0;
printf("\n *pv=%d v=%d",*pv,v);
}
solucion *pv=3 v=3 *pv=0 v=0
#include <stdio.h>
void main()
{
int x[10]={10, 11, 12, 13, 14, 15, 16, 17, 18, 19};
int i;
for(i=0;i<10;i++) {
printf("\ni=%d x[i]=%d *(x+i)=%d &x[i]=%X x+i=%X",i,x[i],*(x+i),&x[i],x+i);
}
return;
}
solucion: i=0 x[i]=10 &x[i]=FFE2 x+i=FFE2
i=1 x[i]=11 &x[i]=FFE4 x+i=FFE4
i=2 x[i]=12 &x[i]=FFE6 x+i=FFE6
i=3 x[i]=13 &x[i]=FFE8 x+i=FFE8
i=4 x[i]=14 &x[i]=FFEA x+i=FFEA
i=5 x[i]=15 &x[i]=FFEC x+i=FFEC
i=6 x[i]=16 &x[i]=FFEE x+i=FFEE
i=7 x[i]=17 &x[i]=FFE0 x+i=FFE0
i=8 x[i]=18 &x[i]=FFE2 x+i=FFE2
i=9 x[i]=19 &x[i]=FFE4 x+i=FFE4
-
Calcular los valores de &v ,pv, *pv, u, &u, pu, *pu.
char u,v='A';
char *pu,*pv=&v;
/*Direcci¢n de u=FBC
Direcci¢n de v=F8D*/
*pv=v+1;
u=*pv+1;
pu=&u;
}
solucion= Valores de: &v=F8D pv=F8D *pv=B u=C &u=FBC pu=FBC *pu=C
-
Calcular los valores de &j ,pi, *pi, i, &i, , pj, pi+2.
#include <stdio.h>
void main ()
{
int i,j=25;
int *pi,*pj=&j;
*pj=j+5;
i=*pj+5;
pi=pj; /*Dirección de i=F9C*/
*pi=i+j;
} /*Dirección de j=FE9*/
solucion= Valores de: &i=F9C &j=FE9 *pj=FE9 i=35 pi=FE9 *pi=65 *pi+2=67
-
Calcular los valores de &a ,&b, &c, pa, pb, pa, &(*pa), *pb, c.
#include <stdio.h>
void main ()
{
float a=0.001
float b=0.003
float c,*pa,*pb;
pa=&a;
*pa=2*a;
pb=&b;
c=3*(*pb-*pa);
}
/* dirección a: 1130
dirección b: 1134
dirección c: 1138 */
solucion &a=1130 &b=1134 &c=1138 pa=1130 *pa=0.002 &(*pa)=1130 pb=1134
*pb=0.003 c=0.003
-
¨Q tipo de argumento se pasa a la funcion?
¨Q tipo informacion devuelve funcion?
¨Q tipo de argumentos formales se definen en la funcion?
¨Para q sirve bucle for?
¨Y cual es el resultado del printf?
#include <stdio.h>
void funcion (int *p)
{
int i, sun=0;
for (i=3; i<5; i++)
{
sun+=*(p+i);
}
printf ("\n\n%d", sun);
return;
}
void main ()
{
int a[5]= {10, 20, 30, 40, 50};
funcion (a+3);
}
solucion: puntero,ninguna,punteros,para ir sumando,90.
Operador (&):El operador & devuelve la dirección en la cual se ha almacenado una variable.
Operador de indireccion ( * ): Sabemos que un puntero apunta a una variable y podremos acceder a esa variable indirectamente. Acceder indirectamente a una variable es averiguar su contenido, por medio de un puntero, usando el operador asterisco(*). No hay que confundir el operador de indireccion* con el operador multiplicador.
DECLARACIÓN DE PUNTEROS
Los punteros, como cualquier otra variable, tienen que ser declarados antes de su uso en un programa. Cuando una variable puntero es definida, su nombre debe ir precedido por un *.
Declaración: TIPO DE DATO * NOMBRE DEL PUNTERO.
El tipo de dato que aparece en la declaración se refiere al tipo de dato que se almacena en la dirección representada por el puntero y no al puntero en si mismo.
Ejemplos: int *p; float *p=&v;
En definitiva la declaración de una variable puntero informa al compilador de 3 cosas:
-
La dirección de la variable (su nombre)
-
El numero de bytes del dato que se apunta, dependiendo del dato al que se apunta.
-
Que esta variable es un puntero.
La declaración de un puntero de caracteres tiene también 3 partes. La única diferencia estriba en que apunta a un carácter en vez de a un entero.
Como un puntero contiene siempre una dirección de memoria, siempre ocupa el mismo espacio al almacenarse, independientemente del dato al que apunte.
En general no tiene sentido asignar un valor entero a un variable puntero porque contiene direcciones.
Es importante en una declaración saber que tipo de dato es la variable al que el puntero apunta, ya que así el compilador sabe el numero de bytes que tiene que examinar para recuperar lo que esta almacenado al acceder al valor de la variable apuntada.
Cuando utilizamos puntero hay que tener en cuenta dos cosas:
-
Al declarar un puntero que el tipo de dato que introduzcamos corresponda con el declarado en el puntero.
-
Se deberá inicializar siempre que se apunte a la dirección deseada
El valor cero de un puntero indica que no se apunta ningún dato valido.
En ocasiones podemos asignar un cero que se usa para indicar condiciones especiales.
En tales condiciones lo mejor es definir una constante simbólica que represente el valor cero y usar NULL en la asignación al puntero, lo que indica que esta asignación representa una asignación especial.
Ejemplo: #define NULL 0 Int *pv=NULL;
Al ser este valor ninguna dirección valida se suele utilizar para inicializar los punteros.
PASO DE PUNTEROS A FUNCIONES
La forma que habíamos visto de pasar argumentos a la función era por valor, pasabas variables pero no cambiaban, la forma de hacer que estos cambios permanezcan, es inicializando variables globales. Otra forma de hacer que los cambios realizados en la función se mantengan es usando los punteros.
A menudo los punteros se pasan a las funciones como argumentos. Esto permite que datos de la porción del programa en la que se llama a la función sean accedidos por esta, modificados dentro ella y luego devueltos al programa de forma que se mantengan los cambios realizados. Esta forma de pasar los argumentos se denomina paso por referencia. Cuando un argumento es pasado por valor, el dato se copia a la función, por lo que cualquier modificación de este dato dentro de la función no es devuelta al punto en el que se llamó a la misma, sin embargo en el paso por referencia, lo que se le pasa a la función es la dirección del dato. El contenido de esta dirección puede ser accedido dentro de la función y modificado conservándose estos cambios cuando la función devuelve el control al punto donde fue llamada.
EJEMPLOS:
#include <stdio.h>
void funcion1(int u, int v)
{
u=0;
v=0;
printf("\n En funcion1: u%d v=%d", u,v);
return;
}
void funcion2(int *pu, int *pv)
{
*pu=0;
*pv=0;
printf("\n En funcion2: *pu=%d *pv=%d", *pu, *pv); //le paso 2 direcciones.
}
void main ()
{
int u=1,v=3;
printf("\n Antes de f1 u=%d, v=%d", u,v);
funcion1 (u,v);
printf("\n Despues de f1 u=%d, v=%d", u,v);
printf("\n Antes de f2 u=%d, v=%d", u,v);
funcion2 (&u,&v);
printf("\n Despues de f2 u=%d, v=%d", u,v);
}
solucion: u=1 v=3
u=0 v=0
u=1 v=3
u=1 v=3
u=0 v=0
u=0 v=0
#include <stdio.h>
int func1 (char c1,char c2)
{
c1='P';
c2='Q';
return( (c1<c2)?c1:c2);
}
int func2 (char *c1,char *c2)
{
*c1='P';
*c2='Q';
return( (*c1==*c2)? *c1:*c2);
}
void main ()
{
char a='X';
char b='Y';
int i,j;
i=func1(a,b);
printf("a=%c b=%c \n",a,b);
printf("i=%d\n",i);
j=func2(&a,&b);
printf("a=%c b=%c \n",a,b);
printf("j=%d\n",j);
}
/* Valores de: i=P j=Q */ /*P=80 Q=81 X=88 Y=89*/
solucion a=x b=y i=80 a=p b=q j=81
-
Programa que te calcula tanto las consonantes y vocales de un texto como los caracteres especiales.
#include <stdio.h>
#include <ctype.h>
void analiza_linea(char linea[],int *pv, int *pc, int *pd, int *pw, int *po)
{
char c;
int cont=0;
while ( (c=toupper(linea[cont])) != '\0' ) {
if (c=='A' || c=='E' || c=='I' || c=='O' || c=='U') *pv+=1;
else
if (c>='A' && c<='Z') *pc+=1;
else
if (c>='0' && c<='9') *pd+=1;
else
if (c==' ' || c=='\t') *pw+=1;
else *po+=1;
cont+=1;
}
return;
}
void main()
{
char linea[80];
int vocales=0, consonan=0, digitos=0, blancos=0, otros=0;
float tvocales=0, tlineas=0, tconso=0, tdigitos=0, tblancos=0,
totros=0;
char seguir;
do {
printf("\nIntroduce una linea: ");
gets(linea);
tlineas+=1;
vocales=0;
consonan=0;
digitos=0;
blancos=0;
otros=0;
analiza_linea(linea, &vocales, &consonan, &digitos, &blancos,
&otros);
printf("\nNumero de vocales : %d", vocales);
printf("\nNumero de consonantes : %d", consonan);
printf("\nNumero de digitos : %d", digitos);
printf("\nNumero de blancos : %d", blancos);
printf("\nOtros : %d", otros);
tvocales+=vocales;
tconso+=consonan;
tdigitos+=digitos;
tblancos+=blancos;
totros+=otros;
printf("\nENTER para seguir");
scanf("%c",&seguir);
}while (seguir=='\n');
printf("\nMedia de vocales :%4.2f", tvocales/tlineas);
printf("\nMedia de consonantes :%4.2f", tconso/tlineas);
printf("\nMedia de digitos :%4.2f", tdigitos/tlineas);
printf("\nMedia de blancos :%4.2f", tblancos/tlineas);
printf("\nMedia de otros :%4.2f", totros/tlineas);
}
En definitiva la unica manera de transformar el valor de una variable en una funcion es mediante punteros tratandolos como los argumentos de esas funciones.
PUNTEROS Y ARRAYS UNIDIMENSIONALES
El nombre de un array es realmente un puntero que apunta al primer elemento de ese array. Por ejemplo, si se tiene un array unidimensional X la dirección del primer elemento se puede expresar de dos formas:
-
&X [0]
-
X
Si por ejemplo queremos acceder a la posición 3 del array se puede poner :
-
&X[3]
-
X+3.
Del mismo modo, para referirnos al contenido de una posición se ponia
-
X[3],
-
ahora se pone *(X+3).
Supongamos que X se ha definido como un array unidimensional de 10 elementos enteros y también sabemos que es posible definir X como un puntero en vez de como un array.
Las dos formas que teníamos de definir un array eran:
-
Int x[10]
-
#define MAX 100
int X[MAX];
-
Ahora lo definimos como int *X; (como un puntero).
la declaración de un puntero no trae acarreada la asignación de memoria por parte del compilador, con lo que en realidad el puntero no puede utilizarse hasta que no se realice una asignación a alguna zona de la memoria.
Es decir, al hacer esta declaración la variable no tiene asignado un bloque de memoria suficientemente grande para almacenar 10 enteros, lo que si ocurre cuando X se define como un array. Para reservar memoria en el caso de declarar X como un puntero en lugar de como un array se usa la función de biblioteca malloc.h.
Esta función reserva un bloque de memoria cuyo tamaño en bytes es equivalente al tamaño de una cantidad, en este caso de una cantidad entera, que estemos tratando. Pero también hay que indicar que tipo de dato es el que necesitamos , el tamaño que ocupa ese tipo de dato (esto se hace a través de sizeof), los elementos ha introducir en ese array e indicar donde vamos a empezar, es decir, que variable nos va a indicar el nombre para hacer referencia a ese array.
Todo esto se resume en esta asignación:
PUNTERO=(TIPO DE DATO*)MALLOC(ELEMENTOS*SIZEOF(TIPO DE DATO) );
En el caso que estamos viendo seria : x=(int*)malloc(10*sizeof(int));
De esta forma ya queda completamente declarado X con 10 posiciones.
Si desconocemos el numero de posiciones usamos N, donde n sera introducido por el usuario.
Seria de esta forma: "X=(int*)malloc(n*sizeof(int))"
EJERCICIOS:
-
Como declarar, llenar y sacar por la pantalla un array.
#include <stdio.h>
#include <malloc.h>
void main ()
{ //lo primero es declarar el array como un puntero
int *tabla;
int n, i ; //n = nº de elementos del array, e i un contador para recorrerlo
do {
printf("\nElemntos: ");
scanf("%d",&n);
} while (n<=0);
//a continuación reservo memoria para guardar los n elementos
tabla=(int *)malloc(n*sizeof(int));
//ahora hay que inidicar que apunte a la primera posición.
//lleno el array
for (i=0;i<n;i++)
{
printf("\nElemento %d : ", i);
scanf("%d", tabla+i); //tabla sin & ya que de por si nos da una direccion.
}
//imprimo el array
for (i=0;i<n;i++)
{
printf("Elemento %d: %d", i,*(tabla+i);
}
}
-
Un array , llenarlo, mostrarlo, ordenarlo, y volverlo a mostrar ordenado, una función para cada cosa, y con punteros.
#include <stdio.h>
#include <malloc.h>
void llenar (int *array , int tamano)
{
int i=0;
for (i=0;i<tamano;i++)
{
printf("\nDime un valor: ");
scanf("%d", array+i);
}
return;
}
void mostrar (int *array, int tamano )
{
int i=0;
for (i=0;i<tamano;i++)
{
printf("Valor %d = %d ",i,*(array+i));
}
return;
}
void ordenar (int *array, int tamano)
{
int i,k,temp;
for (i=1;i<tamano;i++)
{
temp=*(array+i);
k=i-1;
while (*(array+k)>temp&&k>0) {
*(array+k+1)=*(array+k);
k=k-1;
}
if (*(array+k)>temp)
{
*(array+k+1)=*(array+k);
*(array+k)=temp;
}
else
{
*(array+k+1)=temp;
}
}
return;
}
void main ()
{
int *array,tamano=0;
printf("\n Dime el tamaño del array");
scanf("%d", &tamano);
array=(int *)malloc(tamano * sizeof(int));
llenar (array,tamano);
mostrar (array,tamano);
ordenar (array,tamano);
mostrar (array,tamano);
getch();
}
-
dos arrays , llenarlos, mostrarlos, ordenarlos, y volverlo a mostrar ordenados,una vez esto sumarlos y mostrarlos. una función para cada cosa, y con punteros.
#include <stdio.h>
#include <malloc.h>
void llenar (int *array , int tamano)
{
int i=0;
for (i=0;i<tamano;i++)
{
printf("\nDime un valor: ");
scanf("%d", array+i);
}
return;
}
void mostrar (int *array, int tamano )
{
int i=0;
for (i=0;i<tamano;i++)
{
printf("Valor %d = %d ",i,*(array+i));
}
return;
}
void ordenar (int *array, int tamano)
{
int i,k,temp;
for (i=1;i<tamano;i++)
{
temp=*(array+i);
k=i-1;
while (*(array+k)>temp&&k>0) {
*(array+k+1)=*(array+k);
k=k-1;
}
if (*(array+k)>temp)
{
*(array+k+1)=*(array+k);
*(array+k)=temp;
}
else
{
*(array+k+1)=temp;
}
}
return;
}
void suma(int *array, int *array1,int *array2,int a)
{
int i,j;
printf("tabla ordenada");
for(i=0;i<a;i++)
{
(array3+i)=(array1+i)+(array2+i);
}
void main ()
{
int *array,*array1,*array2,tamano=0;
printf("\n Dime el tamaño del array");
scanf("%d", &tamano);
array=(int *)malloc(tamano * sizeof(int));
array2=(int *)malloc(tamano * sizeof(int));
array3=(int *)malloc(tamano * sizeof(int));
llenar (array,tamano);
mostrar (array,tamano);
ordenar (array,tamano);
mostrar (array,tamano);
llenar (array2,tamano);
mostrar (array2,tamano);
ordenar (array2,tamano);
mostrar (array2,tamano);
sumar(array1,array2,array3,tamano);
mostrar(array3);
getch();
}
PUNTEROS Y ARRAYS MULTIDIMENSIONALES
Hasta ahora lo que hemos estado viendo es que un array es un puntero a la primera posición de un array. Para declarar una tabla en la funcion principalse hace int (*x)[]
Para el array multidimensional teníamos que pedir el tamaño de sus filas y columnas ahora también:
int filas, columnas.
Printf(“dame las filas y las columnas”);
Scanf(“%d %d”,filas,columnas);
También hay que declararle el tamaño:
X=(int*)malloc(filas columnas*sizeof(int));
Como se accede a una posicion concreta de la tabla: tenemos que indicar a que fila queremos acceder y a que posición de la columna.
Para especificar la fila es decir la dirección *(x+i)
Entonces para acceder a la dirección de una cierta columna añadimos j es decir *(x+i)+j
Y para acceder al contenido = *(*(x+i)+j)
EJEMPLO :
-
vamos a declarar una matriz llenarla e imprimirla
#include<stdio.h>
#include<malloc.h>
void main()
{
int i,j,filas,columnas,(*x)[]; // en ciertos compiladores hay que introducir valores es decir el valor
de las columnas
printf(“dame la longitud de las filas y las columnas”);
scanf(“%d %d,&filas,&columnas”);
x=(int*)malloc(filas*columnas*sizeof(int));
for(i=0,i<filas;i++)
{
for(j=0;j<columnas;j++)
{
printf (“dame un valor”);
scanf(“%d”,*(x+i)+j);
}
}
for(i=0,i<filas;i++)
{
for(j=0;j<columnas;j++)
{
printf (“%d”,*(*(x+i)+j));
}
}
}
para pasar a una funcion no cambia = llena (x,filas,columnas);
pero a la hora de recibir es void llena (int (*x)[])
-
Ejercicio anterior pero con funciones
#include<stdio.h>
#include<malloc.h>
#define max 100
void llena(int (*x)[max],int filas, int columnas)
{
int i,j;
for(i=0,i<filas;i++)
{
for(j=0;j<columnas;j++)
{
printf (“dame un valor”);
scanf(“%d”,*(x+i)+j);
}
}
return;
}
void imprime(int (*x)[max],int filas,int columnas)
{
int i,j;
for(i=0,i<filas;i++)
{
for(j=0;j<columnas;j++)
{
printf (“%d”,*(*(p+i)+j));
}
}
return;
}
void main()
{
int i,j,filas,columnas ,(*x)[max];
printf(“dame la longitud de las filas y las columnas”);
scanf(“%d %d,&filas,&columnas”);
x=(int*)malloc(filas*columnas*sizeof(int));
llena(x,filas,columnas);
imprime(x,filas,columnas);
}
dependiendo de los compiladores para evitar problemas primero:
se pone: #define maxcol 100
int(*x) [maxcol]
-
Pedir 2 tablas, y obtener uno nuevo que sea la suma de los 2 que nos han
Introducido
#include <stdio.h>
#include <malloc.h>
#define MAXCOL 100
void llena(int (*x)[MAXCOL], int f, int c)
{
int i, j;
for(i=0;i<f;i++) {
for(j=0;j<c;j++) {
printf("\nIntroduce el elemento %d,%d: ",i,j);
scanf("%d", *(x+i)+j);
}
}
return;
}
void saca(int (*x)[MAXCOL], int f, int c)
{
int i, j;
for(i=0;i<f;i++)
{
for(j=0;j<c;j++)
{
printf("\nElemento %d,%d: %d",i,j, *(*(x+i)+j));
}
}
return;
}
void suma(int (*x)[MAXCOL], int (*y)[MAXCOL], int (*z)[MAXCOL], int f, int c)
{
int i, j;
for(i=0;i<f;i++)
{
for(j=0;j<c;j++)
{
(*(*(z+i)+j)) = (*(*(x+i)+j))+(*(*(y+i)+j));
}
}
return;
}
void main()
{
int filas, columnas;
int (*x)[MAXCOL], (*y)[MAXCOL], (*z)[MAXCOL];
do {
printf("\nNumero de filas y de columnas:");
scanf("%d %d",&filas, &columnas);
}while (filas<=0 || columnas<=0);
x = (int *)malloc(filas*columnas*sizeof(int));
y = (int *)malloc(filas*columnas*sizeof(int));
z = (int *)malloc(filas*columnas*sizeof(int));
llena(x, filas, columnas);
llena(y, filas, columnas);
suma(x, y, z, filas, columnas);
saca(z, filas, columnas);
}
-
Cuestion
Float tabla [2][3]={ {1.1, 1.2, 1.3},{2.1,2.2,2.3} }
constestar a: tabla= la posicion del puntero del primer elemento del array
(tabla+1)=la direccion del segunda fila
*(tabla+1)=la direccion del elemento 2.1
(*(tabla+1)+1)= la direccion del elemento 2.2
(*(tabla)+1)= la direccion del elemento 1.2
*(*(tabla+1)+1) es igual al elemento 2.2
*(*(tabla+1))= es igual al elemento 2.1
*(*(tabla)+1)+1= es igual al elemento 2.2
ARRAYS DE PUNTEROS:
es otra forma de representar una tabla
nombre del puntero que apunta al array
Al hora de declararlo se hace así:
#DEFINE MAXFILAS 100
INT *NOMBRE[MAXFILAS]
Como anteriormente hay que asignar el tamaño :
scanf(“%d %d,&fila,&columna);
For (i=0;i<filas;i++)
{
Nombre[i]=(int*)malloc(columnas*sizeof(int))
}
para acceder a una posición de la tabla seria:
X[FILA]+COLUMNA
y para el contenido :
*(X[FILA]+COLUMNA)
vamos a tener una tabla la cual se puede tratar como un puntero o como una array de punteros
en el segundo caso no solamente se tiene la primera direccion sino las siguientes las cuales se guardan en un vector
EJEMPLOS :
-
meter valores e imprimirlos:
#include <stdio.h>
#include <malloc.h>
#define MAXFILA 100
void main(void)
{
int *x[MAXFILA], i, j, filas, columnas;
printf("\nNumero de filas y de columnas: ");
scanf("%d %d", &filas, &columnas);
for(i=0;i<filas;i++)
{
x[i]=(int *)malloc(columnas*sizeof(int));
}
for(i=0;i<filas;i++)
{
printf("\nValores para la fila %d", i);
for(j=0;j<columnas;j++)
{
printf("\nIntroduce el elemento %d",j);
scanf("%d", x[i]+j);
}
}
for(i=0;i<filas;i++)
{
for(j=0;j<columnas;j++)
{
printf("%d", *(x[i]+j));
}
printf("\n");
}
}
-
ejercicio anterior pero con funciones
#include <stdio.h>
#include <malloc.h>
#define MAXFILA 100
void llena(int *x[MAXFILA], int fil, int col)
{
int i, j;
for(i=0;i<fil;i++) {
printf("\nValores para la fila %d", i);
for(j=0;j<col;j++) {
printf("\nIntroduce el elemento %d",j);
scanf("%d", x[i]+j);
}
}
return;
}
void saca(int *x[MAXFILA], int fil, int col)
{
int i, j;
for(i=0;i<fil;i++) {
printf("\nValores para la fila %d", i);
for(j=0;j<col;j++) {
printf("%d", *(x[i]+j));
}
printf("\n");
}
return;
}
void main(void) {
int *x[MAXFILA], i, filas, columnas;
printf("\nNumero de filas y de columnas: ");
scanf("%d %d", &filas, &columnas);
for(i=0;i<filas;i++) {
x[i]=(int *)malloc(columnas*sizeof(int));
}
llena(x, filas, columnas);
saca(x, filas, columnas);
}
-
programa que te sume dos tablas
#include <stdio.h>
#include <malloc.h>
#define max 100
void llena(int *p[max],int a,int b)
{
int i,j;
for (i=0;i<a;i++)
{
for(j=0;j<b;j++)
{
printf("dime el valor\n");
scanf("%d",p[i]+j);
}
}
return;
}
void imprime (int *p[max], int a,int b)
{
int i,j;
for (i=0;i<a;i++)
{
for(j=0;j<b;j++)
{
printf("\nElemento:%d\n", *(p[i]+j));
}
}
return;
}
void suma(int *p1[max], int *p2[max],int *p3[max],int a,int b)
{
int i,j;
printf("tabla ordenada");
for(i=0;i<a;i++)
{
for(j=0;j<b;j++)
{
*(p3[i]+j)=*(p1[i]+j)+ *(p2[i]+j);
}
}
return;
}
void main()
{
int *x[max],fila,columna,*y[max],*z[max],i;
printf("dame el tamaño\n");
scanf("%d %d",&fila,&columna);
for(i=0;i<fila;i++)
{
x[i]=(int *)malloc(columna*sizeof(int));
y[i]=(int *)malloc(columna*sizeof(int));
z[i]=(int *)malloc(columna*sizeof(int));
}
llena(x,fila,columna);
llena (y,fila,columna);
printf("tabla 1");
imprime(x,fila,columna);
printf("tabla 2");
imprime(y,fila,columna);
suma (x,y,z,fila,columna);
printf("tabla 3");
imprime(z,fila,columna);
}
EJERCICIO RESUMEN DE ARRAYS Y PUNTEROS
#include <stdio.h>
#include <malloc.h>
#define max 100
//funcion resultado
void llena4 (char *p[max],int filas ,int columnas,int x[][max],int (*y)[max],int *z[max])
{
int i ,j;
for (i=0;i<filas;i++)
{
for (j=0;j<columnas;j++)
{
if(x[i][j]==*(*(y+i)+j) && x[i][j]==*(z[i]+j))
{
*(p[i]+j)='t';
}
else
{
*(p[i]+j)= 'f';
}
}
}
return;
}
void imprime4 (char *p[max],int filas ,int columnas)
{
int i ,j;
for (i=0;i<filas;i++)
{
for (j=0;j<columnas;j++)
{
printf("%c",*(p[i]+j));
}
printf("\n");
}
return;
}
//arrays de punteros
void llena1( int *p[max], int filas, int columnas)
{
int i,j;
for(i=0;i<filas;i++)
{
for(j=0;j<columnas;j++)
{
scanf("%d",p[i]+j);
}
}
return;
}
//punteros
void llena2 ( int (*p)[max],int filas,int columnas)
{
int i,j;
for(i=0;i<filas;i++)
{
for (j=0;j<columnas;j++)
{
scanf(" %d", *(p+i)+j);
}
}
return;
}
//arrays mutidimensional
void llena3(int p[][max], int filas, int columnas)
{
int i, j;
for (i=0;i<filas;i++)
{
for (j=0;j<columnas;j++)
{
scanf(" %d", &p[i][j]);
}
}
return;
}
//arrays de punteros
void imprime1 (int *p[max],int filas,int columnas)
{
int i,j;
for(i=0;i<filas;i++)
{
for(j=0;j<columnas;j++)
{
printf(" %d", *(p[i]+j));
}
printf("\n");
}
return;
}
// punteros
void imprime2 (int (*p)[max],int filas, int columnas)
{
int i,j;
for(i=0;i<filas;i++)
{
for(j=0;j<columnas;j++)
{
printf(" %d", *(*(p+i)+j));
}
printf("\n");
}
return;
}
//arrays multidimensionales
void imprime3 (int p[][max],int filas, int columnas)
{
int i,j;
for (i=0;i<filas;i++)
{
for(j=0;j<columnas;j++)
{
printf(" %d", p[i][j]);
}
printf("\n");
}
return;
}
void main()
{
//multidi...
int x[max][max];
// puntero
int (*y)[max];
//arrays de punteros
int *z[max];
// tabla 4
int *a[max];
int i,filas,columnas;
printf("dame el numero de filas y de columnas");
scanf("%d %d",&filas,&columnas);
for(i=0;i<filas;i++)
{
z[i]=(int*)malloc(columnas*sizeof(int));
}
y=(int*)malloc(filas*columnas*sizeof(int));
for (i=0;i<filas;i++)
{
a[i]=(char*)malloc(columnas*sizeof(char));//aqui pongo char poque lo que voy a meter son caracteres
}
llena1(z,filas,columnas);
llena2(y,filas,columnas);
llena3(x,filas,columnas);
llena4(a,filas,columnas,x,y,z);
imprime1(z,filas,columnas);
printf("\n\n\n\n");
imprime2(y,filas,columnas);
printf("\n\n\n\n");
imprime3(x,filas,columnas);
imprime4(a,filas,columnas);
}
TEMA 9
“ESTRUCTURAS Y UNIONES”
INTRODUCCION
“En muchas aplicaciones es necesario la creación de nuevos tipos de datos que permitan agrupar información de distintos tipos.
La combinación de muchas variables es una variable, unificando el uso de todas ellas, se denomina estructura.
En una estructura cada variable definida internamente ocupa el tamaño correspondiente al tipo al que pertenece. Existe también la posibilidad de que muchas variables compartan la misma memoria utilizando una unión. En este caso solo se podrá almacenar un dato en esa porción de memoria, siendo referenciado el contenido según al tipo que pertenezca.
Anteriormente hemos estudiado los arrays que es una estructura de datos cuyos elementos son todos del mismo tipo , es decir en un array solamente podía haber o elementos enteros o caracteres etc.…
Una estructura también nos va a servir para guardar elementos pero con la diferencia que en una estructura se pueden guardar elementos de distinto tipo.
Por lo tanto una estructura puede contener elementos enteros, flotantes y caracteres e incluso podemos incluir punteros y arrays como elementos dentro de la estructura,.
cada elemento individual dentro de la estructura se llama miembro”
Definición: una estructura organiza distintos tipos de datos, de manera que se puede hacer referencia a ellos como si fuera una sola unidad.
Una estructura es un conjunto de variables referenciadas bajo un nombre único que será el nombre de un nuevo tipo de dato.
Las estructuras se utilizan para definir nuevos tipos de datos que son conocidos por datos definidos por el usuario.
DECLARACION
STRUCT NOMBRE
{
TIPO MIENBRO 1;
TIPO MIENBRO 2;
TIPO MIENBRO N;
};
Ejemplo :Tenemos una cuenta de la que nos interesa guardar los siguientes datos:.
El numero de cuenta
Saldo
El tipo de cuenta
Nombre del propietario.
#include <stdio.h>
srtruct cuenta
{
int numero de cuenta;
char tipo de cuenta;
char cliente[2];
float saldo;
};
Esta definicion describe una estructura formada por un array de caracteres y por dos variables una de tipo char y otra de tipo int.
En primer lugar aparece la palabra clave struct,esta palabra identifica como una estructura a lo que viene es decir al rotulo o etiqueta.(cuenta)
Es necesario recordar dos aspectos:
-
La definición de una estructura es una sentencia, y por tanto, se termina con un punto y coma
-
Se ha definido una etiqueta(“cuenta”) para identificar una estructura, que representa un tipo de datos abstracto, pero aun no se ha declarado ninguna variable para ello se haria deesta forma: struct nombre_estructura variable;
Siguiendo el ejemplo podria ser struct cuenta cliente
Hay otra forma de declarar una estructura :
TYPEDEF STRUCT
{
TIPO MIENBRO 1;
TIPO MIENBRO 2;
TIPO MIENBRO N;
}
NOMBRE_ESTRUCTURA;
Se utiliza el typedef ya que lo que estamos haciendo es crear un nuevo tipo de datos otorgado por el usuario.
Ejemplo:
#include <stdio.h>
typedef srtruct
{
int numero de cuenta;
char tipo de cuenta;
char cliente[2];
float saldo;
}cuenta;
A partir de ahora se puede definir declarar cualquier variable del nuevo dato que se ha creado para ello habría que poner:
tipos de dato(es decir nombre de la estructura) variable;
siguiendo el ejemplo: cuenta datos;
nota: la estructura se declara debajo de las funciones de biblioteca
PROCESAMIENTO DE LA ESTRUCTURA
Podemos referirnos a un miembro en particular de la estructura utilizando la notacion
NOMBRE DE LA VARIABLE . NOMBRE DEL CAMPO A REFERENCIAR
Ejemplo:
scanf(" %[^\n]",&datos.saldo); // equivale a gets(datos.saldo)
ESTRUCTURAS ANIDADAS.
Una estructura esta compuesta por campos de distintos tipos, siendo una estructura un nuevo tipos de datos creados por el programador para una aplicación concreta.
Es logico pensar que podemos incluir como campo de una estructura a otra estructura.
Por ejemplo
typedef struct
{
int dia;
int mes;
int año;
}
fecha;
srtruct cuenta
{
int numero de cuenta;
char tipo de cuenta;
char cliente[2];
float saldo;
fecha apertura;};
-
programa que coja los datos de un cliente y lo enseñe.
#include<stdio.h>
typedef struct // declaracion de una estructura
{
char nombre[12];
long int dni;
char direccion[20];
}
cliente; // nombre de la estructura o tipo de dato
void main()
{
cliente datos; // declaracion de una variable (datos) de tipo cliente
clrscr();
printf("dame tu nombre\n");
scanf(" %[^\n]",&datos.nombre); // equivale a gets(datos.nombre)
printf("dame tu dni\n");
scanf("%ld",&datos.dni);
printf("dame la direccion\n");
scanf(" %[^\n]",&datos.direccion);
printf("\n\n\nlos datos del primer cliente\n");
printf("nombre:%s\n",datos.nombre);
printf("dni:%8.0ld\n",datos.dni);
printf("direccion:%s\n",datos.direccion);
}
-
Los datos que nos interesa guardar para varios clientes son: (con arrays.)
- El nombre.
- DNI.
- La dirección.
#include<stdio.h>
#define MAX 100
typedef struct
{
char nombre[20];
long int dni;
char direccion[20];
} cliente;
void main ()
{
cliente datos[MAX];
int lista, i;
clrscr ();
do
{
printf (" ¨Cuantos clientes vas a introducir:\n");
scanf (" %d", &lista);
} while (lista<=0);
for (i=0; i<lista; i++)
{
printf ("Introduzca el nombre del cliente.\n");
scanf (" %[^\n]", &datos[i].nombre);
printf ("Introduzca el DNI del cliente.\n");
scanf (" %ld", &datos[i].dni); /*%ld es por el long int*/
printf ("Introduzca la direcci¢n del cliente.\n");
scanf (" %[^\n]", &datos[i].direccion);
printf (" \n");
}
for (i=0; i<lista; i++)
{
printf (" \n");
printf (" Los datos introducidos son:\n");
printf (" Nombre: %s.\n", datos[i].nombre);
printf (" DNI: %ld.\n", datos[i].dni);
printf (" Dirrecci¢n: %s.\n", datos[i].direccion);
}
getch ();
}
-
Realizar este menu:
. añadir cliente
. ver clientes
. buscar clientes
. borrar cliente
. salir
#include<stdio.h>
#define max 100
#include <string.h>
typedef struct
{
char nombre[20];
long int dni;
char direccion[20];
}
cliente;
void main()
{
cliente datos;
cliente array[max];
int i=0,opcion,j,contador=0,k=0;
char nombre[20],eliminar[20];
clrscr();
do{
printf(" opcion 1: añadir cliente\n");
printf(" opcion 2: ver clientes\n");
printf(" opcion 3: buscar cliente\n");
printf(" opcion 4: eliminar cliente\n");
printf(" opcion 5: salir \n\n\n");
scanf("%d", &opcion);
switch(opcion)
{
case 1:
printf(" nombre\n");
scanf(" %[^\n]",&array[i].nombre);
printf(" dni\n");
scanf("%ld",&array[i].dni);
printf(" direccion\n");
scanf(" %[^\n]",&array[i].direccion);
i++;
break;
case 2:
if (i==0)
{
printf("\nno hay ningun cliente\n");
}
else
{
for(j=0;j<i;j++)
{
printf("\n\nlos datos del cliente %d\n",j+1);
printf(" nombre:%s\n",array[j].nombre);
printf(" dni:%8.ld\n",array[j].dni);
printf(" direccion:%s\n",array[j].direccion);
}
}
break;
case 3:
printf("\n\ndame el nombre del cliente que quieres
buscar\n");
scanf (" %[^\n]",&nombre);
clrscr();
for(j=0;j<i;j++)
{
if(strcmp(array[j].nombre,nombre)==0)
{
printf("el cliente %d\n",j+1);
printf("nombre:%s\n",array[j].nombre);
printf("dni:%8.ld\n",array[j].dni);
printf("direccion:%s\n",array[j].direccion);
contador=1;
}
}
if(contador==0)
{
printf("\nel cliente que busca no se encuentra\n");
}
break;
case 4:
printf("dame el cliente a eliminar");
scanf(" %[^\n]",eliminar);
for(j=0;j<i;j++)
{
if(strcmp(eliminar,array[j].nombre)==0)
{
for(k=j+1;k<i;k++)
{
array[j]=array[k];
j++;
}
i--;
}
}
break;
default:
break;
}
}while(opcion!=5);
}
-
Programa anterior pero con funciones
#include<stdio.h>
#define MAX 100
#include <string.h>
typedef struct
{
char nombre[20];
long int dni;
char direccion[20];
}
cliente;
int contador=0;
void introducir(cliente array[])
{
printf(" nombre\n");
scanf(" %[^\n]",&array[contador].nombre);
printf(" dni\n");
scanf("%ld",&array[contador].dni);
printf(" direccion\n");
scanf(" %[^\n]",&array[contador].direccion);
contador++;
return;
}
void ver(cliente array[])
{
int i;
if (contador==0)
{
printf("\nno hay ningun cliente\n");
}
else
{
for(i=0;i<contador;i++)
{
printf("\n\nlos datos del cliente %d\n",i+1);
printf(" nombre:%s\n",array[i].nombre);
printf(" dni:%8.ld\n",array[i].dni);
printf(" direccion:%s\n",array[i].direccion);
}
}
getch();
return;
}
void buscar(cliente array[])
{
int i;
char nombre[20];
printf("\n\ndame el nombre del cliente que quieres
buscar\n");
scanf (" %[^\n]",&nombre);
clrscr();
for(i=0;i<contador;i++)
{
if(strcmp(array[i].nombre,nombre)==0)
{
printf("el cliente %d\n",i+1);
printf("nombre:%s\n",array[i].nombre);
printf("dni:%8.ld\n",array[i].dni);// asi se quitan los ceros
printf("direccion:%s\n",array[i].direccion);
}
if(contador==0)
{
printf("\nel cliente que busca no se encuentra\n");
}
}
return;
}
void eliminar(cliente array[])
{
int i,j;
char eliminar[20];
printf("dame el cliente a eliminar");
scanf(" %[^\n]",eliminar);
for(i=0;i<contador;i++)
{
if(strcmp(eliminar,array[i].nombre)==0)
{
for(j=i+1;j<contador;j++)
{
array[i]=array[j];
i++;
}
contador--;
}
}
return;
}
void main()
{
cliente datos[MAX];
int opcion;
clrscr();
do
{
printf(" opcion 1: añadir cliente\n");
printf(" opcion 2: ver clientes\n");
printf(" opcion 3: buscar cliente\n");
printf(" opcion 4: eliminar cliente\n");
printf(" opcion 5: salir \n\n\n");
scanf("%d", &opcion);
switch(opcion)
{
case 1:
introducir( datos);
break;
case 2:
ver( datos);
break;
case 3:
buscar(datos);
break;
case 4:
eliminar(datos);
break;
default: break;
}
}while(opcion!=5);
}
-
Programa anterior pero hecho por el profesor.
#include <stdio.h>
#include <conio.h>
#include <string.h>
#define MAX 100
int num=0;
typedef struct
{
char nombre[20];
long int dni;
char direccion[20];
}cliente;
void inserta(cliente datos[])
{
printf("\nIntroduzca datos del cliente %d", num+1);
printf("\nNombre: ");
scanf(" %[^\n]", &datos[num].nombre);
printf("\nDNI: ");
scanf(" %ld", &datos[num].dni);
printf("\nDireccion: ");
scanf(" %[^\n]", &datos[num].direccion);
num+=1;
return;
}
void muestra(cliente registro, int num_cliente)
{
printf("\n\n----Datos del cliente %d----", num_cliente+1);
printf("\nNombre: %s", registro.nombre);
printf("\nDNI: %ld", registro.dni);
printf("\nDireccion: %s\n", registro.direccion);
return;
}
int busca_posicion(cliente datos[])
{
int i=0, encontrado=-1;
char nombre[20];
printf("\nIntroduce el nombre del cliente a tratar: ");
scanf(" %[^\n]", &nombre);
while ( (i<num)&&(encontrado==-1) ) {
if (strcmp(datos[i].nombre, nombre)==0) encontrado=i;
else i+=1;
}
return(encontrado);
}
int busca_dni(cliente datos[])
{
int i=0, encontrado=-1;
long int dni;
printf("\nIntroduce el dni del cliente a buscar: ");
scanf("%ld", &dni);
while ( (i<num)&&(encontrado==-1) ) {
if (datos[i].dni==dni) encontrado=i;
else i+=1;
}
return(encontrado);
}
void busca(cliente datos[])
{
int posicion, opcion;
printf("\n\n1.Busqueda por nombre");
printf("\n2.Busqueda por DNI");
scanf("%d", &opcion);
switch (opcion) {
case 1:
posicion=busca_posicion(datos);
if (posicion>=0) {
muestra(datos[posicion], posicion);
}
else {
printf("\nEl cliente no se encuentra en la lista\n");
}
break;
case 2:
posicion=busca_dni(datos);
if (posicion>=0) {
muestra(datos[posicion], posicion);
}
else {
printf("\nEl cliente no se encuentra en la lista\n");
}
break;
default:
printf("\nOpcion introducida no valida");
break;
}
return;
}
void elimina(cliente datos[])
{
int posicion, i;
posicion=busca_posicion(datos);
if (posicion>=0)
{
for(i=posicion;i<num;i++)
{
datos[i]=datos[i+1];
}
num-=1;
}
else
{
printf("\nEl cliente no se encuentra en la lista\n");
}
return;
}
void main(void)
{
cliente datos[MAX];
int i, opcion;
do {
printf("\n1.Introducir un nuevo cliente\n");
printf("2.Mostrar los clientes existentes\n");
printf("3.Buscar un cliente\n");
printf("4.Eliminar un cliente\n");
printf("5.Salir del programa\n");
printf("\nIntroduce una opcion: ");
scanf("%d", &opcion);
switch (opcion) {
case 1:
inserta(datos);
break;
case 2:
if (num==0) printf("\nNo hay ningun cliente en la
lista\n");
else {
for(i=0;i<num;i++)
{
muestra(datos[i], i);
}
}
break;
case 3:
if (num==0)
printf("\nNo hay ningun cliente en la
lista\n");
else
{
busca(datos);
}
break;
case 4:
if (num==0)
printf("\nNo hay ningun cliente en la
lista\n");
else
{
elimina(datos);
}
break;
case 5:
printf("\n---FIN DEL PROGRAMA---\n");
break;
default:
printf("\nOpcion introducida no valida\n");
break;
}
}while(opcion!=5);
getch();
}
-
Programa anterior teniendo en cuenta que puede haber mas de un cliente con el mismo nombre cuando se quiera eliminar un cliente
#include <stdio.h>
#include <conio.h>
#include <string.h>
#define MAX 100
int num=0;
typedef struct {
char nombre[20];
long int dni;
char direccion[20];
}cliente;
void inserta(cliente datos[])
{
printf("\nIntroduzca datos del cliente %d", num+1);
printf("\nNombre: ");
scanf(" %[^\n]", &datos[num].nombre);
printf("\nDNI: ");
scanf(" %ld", &datos[num].dni);
printf("\nDireccion: ");
scanf(" %[^\n]", &datos[num].direccion);
num+=1;
return;
}
void muestra(cliente registro, int num_cliente)
{
printf("\n\n----Datos del cliente %d----", num_cliente+1);
printf("\nNombre: %s", registro.nombre);
printf("\nDNI: %ld", registro.dni);
printf("\nDireccion: %s\n", registro.direccion);
return;
}
/*Devuelve ctos clientes hay con el mismo nombre*/
int busca_posicion(cliente datos[], int *sitio)
{
int i=0, encontrado=0;
char nombre[20];
printf("\nIntroduce el nombre del cliente a tratar: ");
scanf(" %[^\n]", &nombre);
for (i=0;i<num;i++) {
if (strcmp(datos[i].nombre, nombre)==0) {
muestra(datos[i], i);
(*sitio)=i;
printf("\n");
encontrado+=1;
}
}
return(encontrado);
}
int busca_dni(cliente datos[])
{
int i=0, encontrado=-1;
long int dni;
printf("\nIntroduce el dni del cliente a tratar: ");
scanf("%ld", &dni);
while ( (i<num)&&(encontrado==-1) ) {
if (datos[i].dni==dni) encontrado=i;
else i+=1;
}
return(encontrado);
}
void busca(cliente datos[])
{
int posicion, opcion;
int lugar;
printf("\n\n1.Busqueda por nombre");
printf("\n2.Busqueda por DNI");
scanf("%d", &opcion);
switch (opcion) {
case 1:
posicion=busca_posicion(datos, &lugar);
if (posicion==0)
printf("\nEl cliente no se encuentra en la lista\n");
break;
case 2:
posicion=busca_dni(datos);
if ( (posicion)>=0) {
muestra(datos[posicion], posicion);
}
else
{
printf("\nEl cliente no se encuentra en la lista\n");
}
break;
default:
printf("\nOpcion introducida no valida");
break;
}
return;
}
void quita(cliente datos[], int lugar)
{
int i;
for(i=lugar;i<num;i++) {
datos[i]=datos[i+1];
}
num-=1;
printf("\nEl cliente ha quedado eliminado.\n");
return;
}
void elimina(cliente datos[])
{
int posicion;
int sitio;
posicion=busca_posicion(datos, &sitio);
switch (posicion)
{
case 0: //no hay clientes con ese nombre
printf("\nEl cliente no se encuentra en la lista\n");
break;
case 1: //solamente hay un cliente con ese nombre
quita(datos, sitio);
break;
default: //hay mas de un cliente con ese nombre
printf("\nHay mas de un cliente con ese nombre");
posicion=busca_dni(datos);
if (posicion>=0) {
quita(datos, posicion);
}
else
printf("\nNo hay clientes con ese DNI en la lista\n");
break;
}
return;
}
void main(void)
{
cliente datos[MAX];
int i, opcion;
do {
printf("\n1.Introducir un nuevo cliente\n");
printf("2.Mostrar los clientes existentes\n");
printf("3.Buscar un cliente\n");
printf("4.Eliminar un cliente\n");
printf("5.Salir del programa\n");
printf("\nIntroduce una opcion: ");
scanf("%d", &opcion);
switch (opcion)
{
case 1:
inserta(datos);
break;
case 2:
if (num==0) printf("\nNo hay ningun cliente en la
lista\n");
else {
for(i=0;i<num;i++) {
muestra(datos[i], i);
}
}
break;
case 3:
if (num==0)
printf("\nNo hay ningun cliente en la
lista\n");
else {
busca(datos);
}
break;
case 4:
if (num==0)
printf("\nNo hay ningun cliente en la
lista\n");
else {
elimina(datos);
}
break;
case 5:
printf("\n---FIN DEL PROGRAMA---\n");
break;
default:
printf("\nOpcion introducida no valida\n");
break;
}
}while(opcion!=5);
getch();}
ESTRUCTURAS Y PUNTEROS
La dirección de comienzo de una estructura puede accederse de la misma manera que cualquier otra dirección mediante el uso del operador indireccion
Si variable V representa un tipo de estructura entonces &v representa la dirección de comienzo de la estructura es decir de la variable, además podemos declarar un puntero a una estructura escribiendo
TIPO DE ESTRUCTURA* PUNTEROVARIABLE
Aquí tenemos un puntero que apunta a un dato del tipo de la estructura que hayamos definido
Para que ese puntero se quede con la dirección de la variable ponemos
PUNTEROVARIABLE= &VARIABLE
Typedef struct
{
Char nombre[20];
Long int dni;
Char direccion[20];
}cliente;
cliente datos;
cliente *pdatos;
pdatos=&datos
para acceder a los campos poniamos
datos.nombre
ahora
(*PDATOS).NOMBRE;
hay otra forma de acceder al valor de los campos: PDATOS->NOMBRE
EJEMPLO:
#include<stdio.h>
#define max 100
typedef struct
{
char nombre[20];
long int dni;
char direccion[20];
}cliente;
void main()
{
cliente datos;
cliente *pdatos;
pdatos=&datos;
printf("dame el nombre\n");
scanf ( " %[^\n]",&datos.nombre);
printf("dame la direccion\n");
scanf ( " %[^\n]",&datos.direccion);
printf("dame el dni\n");
scanf("%ld",&datos.dni);
printf("el nombre que ha metido es:%s\n",datos.nombre);
printf("el nombre que ha metido es:%s\n",(*pdatos).nombre);
printf("el nombre que ha metido es:%s\n",pdatos->nombre);
printf("el dni que ha metido es:%ld\n",datos.dni);
printf("el dni que ha metido es:%ld\n",(*pdatos).dni);
printf("el dni que ha metido es:%ld\n",pdatos->dni);
printf("la direccion que ha metido es:%s\n",datos.direccion);
printf("la direccion que ha metido es:%s\n",(*pdatos).direccion);
printf("la direccion que ha metido es:%s\n",pdatos->direccion);
}
-
Programa anterior pero con varios clientes.
#include<stdio.h>
#define MAX 100
typedef struct {
char nombre[20];
long int dni;
char direccion[20];
} cliente;
void main () {
cliente datos[MAX];
cliente *pdatos;
int lista, i;
clrscr();
do {
printf ("¨Cuantos clientes nuevos vas a introducir?");
scanf ("%d", &lista);
}while (lista<=0);
for (i=0; i<lista; i++) {
printf ("Introduzca los datos del %d§ cliente.\n", i+1);
printf("\n\n NOMBRE: ");
scanf(" %[^\n]",datos[i].nombre);
printf("\n DNI: ");
scanf("%ld",&datos[i].dni);
printf("\n DIRECCIàN: ");
scanf(" %[^\n]",datos[i].direccion);
}
pdatos=&datos;
clrscr ();
printf ("\n\nLos datos se van a imprimir tres veces.");
printf ("\n\nPrimera forma: ");
for (i=0; i<lista; i++) {
printf ("El nombre es: %s.\n", datos[i].nombre);
printf ("El DNI es: %d.\n", datos[i].dni);
printf ("La direcci¢n es: %s.\n", datos[i].direccion);
}
printf ("\n\nSegunda forma: ");
for (i=0; i<lista; i++) {
printf ("El nombre es: %s.\n", (*(pdatos+i)).nombre);
printf ("El DNI es: %d.\n", (*(pdatos+i)).dni);
printf ("La direcci¢n es: %s.\n", (*(pdatos+i)).direccion);
}
printf ("\n\nTercera forma: ");
for (i=0; i<lista; i++) {
printf ("El nombre es: %s.\n", (pdatos+i)->nombre);
printf ("El DNI es: %d.\n", (pdatos+i)->dni);
printf ("La direcci¢n es: %s.\n", (pdatos+i)->direccion);
}
getch ();
}
-
programa de busqueda de clientes en un array
#include <stdio.h>
#define MAX 3
#define NULL 0
typedef struct {
char nombre[20];
long int dni;
char direccion [20];
}cliente;
cliente *busca(cliente datos[], long int n)
{
//devuelve un puntero,es decir:una direccion.
int i;
for (i=0; i<3; i++)
{
if (datos[i].dni==n)
{
return (&datos[i]);
}
}
return (NULL);
}
void main () {
cliente *pdatos;
cliente datos [MAX]= {{"Pepe", 1245, "Santiago"},{"Luis", 3875,
"Burgos"},{"Maria", 9540, "Alegria"}};
long int numero;
clrscr();
printf ("\nN£mero a buscar: ");
scanf ("%ld", &numero);
pdatos=busca(datos, numero);
if (pdatos==NULL) {
printf ("\nNo existe.");
}else {
printf ("\nNombre: %s.", pdatos->nombre);
printf ("\nDNI: %ld.", pdatos->dni);
printf ("\nDirecci¢n: %s.", pdatos->direccion);
}
getch();
}
LISTAS ENLAZADAS
Una lista va a combinar un puntero (indica el principio de la lista) y una estructura.
Para hacer listas utilizaremos :
STRUCT NOMBRE
{
TIPO MIENBRO 1;
TIPO MIENBRO 2;
TIPO MIENBRO N;
};
TYPEDEF “STRUCT” NOMBRE NODO
Struct cliente{
Char nombre[20];
Longint dni;
Char direccion[20];
Struct cliente nombre*siguiente;
};
typedef “struct” cliente nodo;
EJEMPLOS :
-
Programa que te crea un nodo
#include <stdio.h>
#include <stdlib.h>
#define null 0
struct lista{
char nombre[20];
long int dni;
int numero;
struct lista*siguiente;
};
typedef struct lista nodo;
void main(){
//intoducir un cliente.
nodo *inicio=null;
inicio=(nodo*)malloc(sizeof (nodo)); //reservar espacio
printf("\n nombre");
scanf(" %[^\n]",inicio->nombre);
printf("dni\n");
scanf("%ld",&inicio->dni);
printf("\n numero");
scanf("%d",&inicio->numero);
inicio-> siguiente= NULL;
printf("\n nombre: %s",inicio->nombre");
printf("\n DNI: %ld",inicio->dni);
printf("\n numero:%d",inicio->numero);
}
-
Programa que te crea una lista con dos nodos
# include <stdio.h>
#include <stdlib.h>
#define null 0
struct lista
{
char nombre[20];
long int dni;
int numero;
struct lista*siguiente;
};
typedef struct lista nodo;
void main(){
nodo *inicio=null;
nodo *temporal=null;// es otro puntero que sustituye a inicio ya que si se toca inicio este perderia su valor inicial.
inicio=(nodo*)malloc(sizeof (nodo)); //reservar espacio/
printf("\n NOMBRE\n ");
scanf(" %[^\n]",inicio->nombre);
printf("\n DNI\n");
scanf("%ld",&inicio->dni);
printf("\n NUMERO");
scanf("%d",&inicio->numero);
inicio-> siguiente= NULL;
inicio->siguiente=(nodo*)malloc(sizeof(nodo));
printf("\n NOMBRE\n ");
scanf(" %[^\n]",inicio->siguiente->nombre);
printf("\n DNI\n");
scanf("%ld",&inicio->siguiente->dni);
printf("\n NUMERO");
scanf("%d",&inicio->siguiente->numero);
inicio->siguiente->siguiente=NULL;
/*printf("\n nombre: %s",inicio->nombre);
printf("\n DNI: %ld",inicio->dni);
printf("\n numero:%d",inicio->numero);
printf("\n nombre: %s",inicio->siguiente->nombre);
printf("\n DNI: %ld",inicio->siguiente->dni);
printf("\n numero:%d",inicio->siguiente->numero);*/
temporal=inicio;
en el caso de que la lista tenga muchos nodos para imprimir los datos se hace asi:
while(temporal!=null)
{
printf("\n nombre: %s",temporal->nombre);
printf("\n DNI: %ld",temporal->dni);
printf("\n numero:%d",temporal->numero);
temporal=temporal->siguiente;
}
-
Programa que te permita hacer las siguientes operaciones con una lista:
Crear lista.
Anadir nodo tanto al principio como al final.
Buscar nodo
Eliminar nodo
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define NULL 0
struct lista_elem{
char nombre[20];
int num_cliente;
long int dni;
char direccion[20];
struct lista_elem *siguiente;
};
typedef struct lista_elem nodo;
void pide_datos(nodo *p) {
printf("\n\nNombre: "); //Pedimos los datos
scanf(" %[^\n]",p->nombre);
printf("\nNumero de cliente: ");
scanf("%d", &p->num_cliente);
printf("\nDNI: ");
scanf("%ld", &p->dni);
printf("\nDireccion: ");
scanf(" %[^\n]", p->direccion);
p->siguiente=NULL;
return;
}
//Inserta el primer elememto de la lista
void insertar(nodo *principio)
{
pide_datos(principio);
return;
}
//Añade un elemento al final de la lista
nodo *anadir_final(nodo *principio)
{
nodo *auxiliar;
auxiliar=principio;
while (auxiliar->siguiente!=NULL) {
auxiliar=auxiliar->siguiente;
}
auxiliar->siguiente=(nodo *)malloc(sizeof(nodo));
pide_datos(auxiliar->siguiente);
return(principio);
}
//Inserta al principio de la lista
nodo *anadir_primero(nodo *principio)
{
nodo *auxiliar;
auxiliar=(nodo *)malloc(sizeof(nodo));
pide_datos(auxiliar);
auxiliar->siguiente=principio;
principio=auxiliar;
return(principio);
}
void mostrar(nodo *puntero)
{
nodo *registro;
registro=puntero;
while(registro!=NULL) {
printf("\n\n\nEl nombre es : %s", registro->nombre);
printf("\nEl numero es : %d", registro->num_cliente);
printf("\nEl dni es : %ld", registro->dni);
printf("\nLa direccion es : %s", registro->direccion);
registro=registro->siguiente;
}
return;
}
int menu(void)
{
int opci;
printf("\n\n1.CREAR lista enlazada");
printf("\n2.A¥ADIR nuevo elemento al final de la lista");
printf("\n3.A¥ADIR nuevo elemento al principio de la lista");
printf("\n4.MOSTRAR lista enlazada");
printf("\n5.BUSCAR un elemento de la lista enlazada");
printf("\n6.ELIMINAR un elemento de la lista enlazada");
printf("\n7.SALIR del programa");
printf("\nIntroduce una opcion: ");
scanf("%d", &opci);
return(opci);
}
nodo *buscar(nodo *p)
{
long int numero;
nodo *aux;
printf("\n\nIntroduce el dni del cliente a buscar: ");
scanf("%ld", &numero);
aux=p;
while(aux!=NULL) {
if (aux->dni==numero)
return(aux);
aux=aux->siguiente;
}
return(NULL);
}
nodo *elimina(nodo *p, nodo *temp)
{
nodo *anterior;
if (temp==p) {//Solamente hay un elemento en la lista
p=NULL;
free(temp);
}
else {
anterior=p;
while(anterior->siguiente!=temp) {
anterior=anterior->siguiente;
}
anterior->siguiente=temp->siguiente;
free(temp);
}
return(p);
}
void main(void) {
int opcion;
nodo *principio=NULL;//Puntero al primer elemnto de la lista
nodo *temp;
clrscr();
opcion=menu();
while (opcion!=7) {
switch (opcion)
{
case 1:
if (principio==NULL)
{
principio=(nodo *)malloc(sizeof(nodo));
insertar(principio);
}
else
printf("\n\nLa lista ya existe");
break;
case 2: if (principio==NULL)
printf("\n\nNo hay clientes");
else
principio=anadir_final(principio);
break;
case 3:
if (principio==NULL)
printf("\n\nNo hay clientes");
else
principio=anadir_primero(principio);
break;
case 4:
if (principio==NULL)
printf("\n\nNo hay clientes");
else
mostrar(principio);
break;
case 5:
if (principio==NULL)
printf("\n\nNo hay clientes");
else
{
temp=buscar(principio);
if (temp==NULL)
printf("\n\nEl cliente no esta en la
lista");
else
{
printf("\n\nNombre: %s", temp->nombre);
printf("\nNumero cliente: %d", temp-
>num_cliente);
printf("\nDNI: %ld", temp->dni);
printf("\nDireccion: %s", temp->direccion);
}
}
break;
case 6: if (principio==NULL)
printf("\n\nNo hay clientes");
else
{
temp=buscar(principio);
if (temp==NULL)
printf("\n\nEl cliente no esta
en la lista");
else
principio=elimina(principio, temp);
}
break;
case 7: printf("\n\nFin del programa");
break;
default:printf("\n\nOpcion no valida");
break;
}
opcion=menu();
}
}
}
TEMA 10
“FICHEROS”
-
INTRODUCCION
En la mayoría de las aplicaciones es necesario guardar información de forma permanente.
Hasta ahora todos los mecanismos de almacenamiento de información(constantes,variables,estructuras,vectores,tablas,punteros..etc)enumerados en unidades anteriores eran volátiles. Es decir cuando el programa que los ejecutaba termina su ejecución desaparecen y la información contenida en ellos se pierde.
Para resolver este problema se necesitan estructuras de datos externas al programa.
Al ser externas no desaparecen con el programa a terminar su ejecución.
En C la estructura de datos externa básica es el fichero o archivo.
Un archivo se puede definir como una estructura de datos consistente en una secuencia de componentes del mismo tipo, almacenados de forma externa al programa, generalmente en dispositivos de almacenamiento auxiliar.
A cada uno de los componentes de un fichero se llama registro .
A su vez un registro esta formado por un conjunto de informaciones de distintos tipo que hacen referencia al mismo registro y que se denominan campos
Antes de que le programa pueda acceder a un fichero, debe de haber alguna información especifica al conjunto del mismo.
Esta información se almacena en una estructura.
-
APERTURA Y CIERRE DE UN FICHERO:
El primer paso cuando se trabaja con un fichero consiste en establecer un área de buffer en el cuales e va almacenar temporalmente la información mientras se transmite entre la memoria y el archivo de datos ,por lo tanto lo primero que hay que hacer es declarar ese área:
FILE * NOMBRE;
Los siguiente que queremos hacer es abrir ese archivo, esto se realiza a través de una función llamada FOPEN( ).
Esta función es una función controlada por tres parámetros.
El primero es el nombre de l fichero que se va a abrir.
El segundo parámetro describe el uso que se va a destinar a este fichero. Existen varios usos entre los cuales están:
r: le abrimos solamente para lectura
w: le abrimos solamente para escritura.
a: abre un archivo existente para añadir información al final del fichero.
r+: abre un fichero existente y es de lectura y escritura
w+: abre un fichero nuevo para escritura y lectura
El tercer parámetro es un puntero al fichero: su valor se devuelve en la función, es decir,
la función FOPEN devuelve un puntero al principio del buffer que hibamos a asociar al fichero.
FILE *NOMBRE;
NOMBRE=FOPEN(“NOMBRE DEL FICHERO.EXTENSION”,MODO CON EL QUE QUEREMOS ABRIR EL FICHERO);
Nombre es un puntero que tiene dos valores: NULL cuando FOPEN no ha podido abrir el fichero que le hemos indicado y distinto de NULL cuando si se ha podido abrir.
Los casos de que la función no pueda abrir el fichero van desde que puede que ese archivo no exista hasta que sea por ejemplo de lectura y le queramos acceder a el como de escritura
IF ( (FICHERO=FOPEN("EJEMPLO.DAT","W"))==NULL)
PRINTF("\NERROR EN LA APERTURA DEL FICHERO");
ELSE {
Despues de haber realizado las operciones de escritura y/o lectura dependiendo del tipo de fichero que sea nada mas terminar, lo que hay que hacer es cerrar dicho fichero.
La funcion que se encarga de realizar esto es FCLOSE( ).
El argumento de dicha funcion es el puntero al fichero y no el nombre de dicho fichero:
FCLOSE (NOMBRE);
Ejercicios:
-
Programa gracias a cual se escriban cuatro pares de numeros en un fichero
#Include<stdio.h>
Void main()
{
file*fichero
int n1,n2,i;
fichero=fopen(“ejemplo2.dat”,”w”);
if(fichero==null)
{
printf(“\nerror en la apertura”);
}
else
{
for(i=0;i<4;i++)
{
printf(“valores”);
scanf(“ %d %d,&n1,&n2);
fprintf(fichero,”%d %d\n”,n1,n2); // escribe en el fichero
}
}
Fclose(fichero);
}
-
Programa gracias al cual te imprima por pantalla los valores de un fichero
#Include <stdio.h>
Void main()
{
File * fich;
Int a,b;
If ( ( fich=fopen(“ejemplo2.dat”,”r”))==null)
printf(“error);
Else{
fscanf(fich,”%d %d”,&a,&b);
while(¡ feof(fich))
{
printf(“%d %d”,a,b);
fscanf(fich, “ %d %d”, &a, &b);
}
}
Fclose(fich)}
-
Programa que te escriba en un fichero cuatro pares de numeros y caracteres.
# Include < stdio.h>
Void main()
{
file * fich;
int i, num;
Char nombre[20];
If ( ( fich=fopen(“ejemplo2.dat”,”w”))==null)
printf(“error);
Else
{
for(i=0;i<4;i++)
{
printf(“valores”);
scanf(“ %d %[ ^\n],&num,nombre);
fprintf(fichero,”%d %[^\n]\n”,num,nombre);
}
}
Fclose(fichero);
}
-
Programa que te escriba los datos de un cliente en un fichero mediante una estructura
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define NULL 0
typedef struct{
char nombre[20];
int num;
}cliente;
void main(void) {
FILE *fichero;
cliente aux;
int i;
if ( (fichero=fopen("ejemplo.dat","w"))==NULL)
printf("\nError en la apertura del fichero");
else {
for(i=0;i<4;i++) {
printf("\nNombre: ");
scanf(" %[^\n]", &aux.nombre);
printf("\nNumero: ");
scanf("%d", &aux.num);
fwrite(&aux, sizeof(cliente), 1, fichero);
}
}
fclose(fichero);
}
-
Programa que acceda aun fichero para mostrar por pantalla los caracteres y numeros escritos en el programa anterior.
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define NULL 0
typedef struct{
char nombre[20];
int num;
}cliente;
void main(void) {
FILE *fichero;
cliente aux;
if ( (fichero=fopen("ejemplo.dat","r"))==NULL)
printf("\nError en la apertura del fichero");
else {
fread(&aux, sizeof(cliente), 1, fichero);
while(!feof(fichero)) {
printf("\n\nEl nombre es: %s", aux.nombre);
printf("\nEl numero es: %d", aux.num);
fread(&aux, sizeof(cliente), 1, fichero);
}
}
fclose(fichero);
}
-
ALGORITMO DE ACTUALIZACIÓN DE FICHEROS
Vamos a suponer que tenemos dos ficheros con dos campos enteros: 1.- clientes con los campos num_cliente y saldo. 2.- bonificaciones con los campos num_cliente y bonif. Queremos obtener otro fichero nuevo con los campos num_cliente y saldo+bonificación.
Para realizar esto se utiliza la tabla de verdad:
| ////// | CLIENTES | BONIFICACIONES |
| C1 | 1 | 1 |
| C2 | 1 | 0 |
| C3 | 0 | 1 |
C1 actualizar el saldo y escribir en nuevo.
C2 sacar mensaje por pantalla
C3 escribir en nuevo
Leer registro clientes
Leer registro bonificaciones
Calcular numero_clinete mínimo
Mientras (num_cliente_cliente!=MAX || num_cliente_bonif!=MAX) hacer
Si (num_cliente_cliente==mínimo && num_cliente_bonif==mínimo)
Tratamiento C1
Leer registro clientes
Leer registro bonificaciones
Sino
Si (num_cliente_cliente==mínimo)
Tratamineto C2
Leer registro clientes
Leer registro bonificaciones
Sino
Tratamiento C3
Leer registro bonificaciones
Fin si
Fin si
Calrcular número_cliente mínimo
Fin mientras
El MAX se utiliza para cuando lleguemos a final de fichero le asignemos ese máximo al número de cliente.
-
Programa que te actualice un fichero;
#include <stdio.h>
#define MAX 10000
typedef struct
{
int ncliente;
int saldo;
}cliente;
typedef struct
{
int ncliente;
int bonificacion;
}bonif;
int calcular_minimo (int aux.ncliente,int temp.ncliente)
{
int minimo;
if( (aux.ncliente==temp.ncliente) || (aux.ncliente<temp.ncliente) )
{
minimo=aux.ncliente;
}
else
{
minimo=temp.ncliente;
}
return(minimo);
}
void main()
{
cliente aux;
bonif temp;
FILE *cli;
FILE *bon;
FILE *nuevo;
cli=fopen("clientes.dat","r");
bon=fopen("bonificaciones.dat","r");
nuevo=fopen("salida.dat","w");
if(cli==NULL || bon==NULL || nuevo==NULL);
{
printf("\nERROR");
}
else
{
fread(&aux,sizeof(cliente),1,cli);
if( feof(cli) )
{
aux.ncliente=MAX;
}
fread(&temp,sizeof(bonif),1,bon);
if( feof(bon) )
{
temp.ncliente=MAX;
}
minimo=calcular_minimo(aux.ncliente,temp.ncliente);
while(aux.ncliente!=MAX || temp.ncliente!=MAX)
{
if(aux.ncliente==minimo && temp.ncliente==minimo)
{
aux.saldo=aux.saldo+temp.bonificacion;
fwrite(&aux,sizeof(cliente),1,nuevo);
fread(&aux,sizeof(cliente),1,cli);
if( feof(cli) )
{
aux.ncliente=MAX;
}
fread(&temp,sizeof(bonif),1,bon);
if( feof(bon) )
{
temp.ncliente=MAX;
}
}
else
{
if(aux.ncliente==min)
{
printf("El cliente %d ha causado
baja.\n",aux.ncliente);
fread(&aux,sizeof(cliente),1,cli); //funci¢n
if( feof(cli) )
{
aux.ncliente=MAX;
}
}
else
{
fwrite(&aux,sizeof(cliente),1,nuevo);
fread(&temp,sizeof(bonif),1,bon);
if( feof(bon) )
{
temp.ncliente=MAX;
}
}
}
minimo=calcular_minimo(aux.ncliente,temp.ncliente);
}
}
fclose(nuevo);
fclose(bon);
fclose(cli);
}
-
Programa que te actualice un fichero hecho con funciones.
#include <stdio.h>
#include <stdlib.h>
#define MAX 10000
typedef struct{
int num_cliente;
int saldo;
}cliente;
typedef struct{
int num_cliente;
int bonificacion;
}datos;
int calc_minimo(int a, int b)
{
if (a<=b) return(a);
else return(b);
}
cliente lee_viejo(FILE *viejo)
{
cliente aux;
fread(&aux, sizeof(cliente), 1, viejo);
if (feof(viejo)) aux.num_cliente=MAX;
return(aux);
}
datos lee_datos(FILE *modif)
{
datos aux;
fread(&aux, sizeof(datos), 1, modif);
if (feof(modif)) aux.num_cliente=MAX;
return(aux);
}
void main(void)
{
FILE *viejo;
FILE *modif;
FILE *nuevo;
int minimo;
cliente aux;
datos aux1;
viejo=fopen("clientes.dat","r");
modif=fopen("datos.dat","r");
nuevo=fopen("nuevo.dat","w");
if (viejo==NULL || modif==NULL || nuevo==NULL)
printf("\nError en la apertura de los ficheros");
else
{
aux=lee_viejo(viejo);
aux1=lee_datos(modif);
minimo=calc_minimo(aux.num_cliente, aux1.num_cliente);
while (aux.num_cliente!=MAX || aux1.num_cliente!=MAX)
{
if((aux.num_cliente==minimo)&&(aux1.num_cliente==minimo))
{
aux.saldo=aux.saldo+aux1.bonificacion;
fwrite(&aux, sizeof(cliente), 1, nuevo);
aux=lee_viejo(viejo);
aux1=lee_datos(modif);
}
else
{
if (aux.num_cliente==minimo)
{
printf("\nEl cliente %d ha causado baja.",
aux.num_cliente);
aux=lee_viejo(viejo);
}
else
{
fwrite(&aux1, sizeof(cliente), 1, nuevo);
aux1=lee_datos(modif);
}
}
minimo=calc_minimo(aux.num_cliente, aux1.num_cliente);
}
}
fclose(nuevo);
fclose(modif);
fclose(viejo);
}
-
FUNCIONES DE TRATAMIENTOS DE FICHEROS:
FPRINTF y FSCANF se comportan igual que printf y scanf, excepto que requieren un argumento adicional para apuntar al fichero correspondiente
El formato general de estas dos funciones es:
FPRINTF(“NOMBRE DEL PUNTERO ,LISTA DE ARGUMENTOS”);
FSCANF(“NOMBRE DEL PUNTERO;LISTA DE ARGUMENTOS”);
Ejemplos:
fscanf(fich, “ %d %d”, &a, &b);
fprintf(fichero,”%d %[^\n]\n”,num,nombre);
FEOF se utiliza para saber cuando es el final de fichero , es decir esta funcion devuelve distinto de cero si se ha alcanzado el final de fichero señalado por el puntero declarado anteriormente:
Ejemplo:
if( feof(bon) )
{
temp.ncliente=MAX;
}
Ademas de estas fuciones de tratamiento de ficheros se encuentran
FREAD y FWRITE.
FREAD ( ) lee el archivo, previamente abierto, indicado por el nombre del puntero a ese fichero FILE *FICHERO, el numero de veces indicado por el NUMERO, el numero de bytes indicado por el tamaño (SIZE OF( TIPO DE DATO))y lo almacena en el puntero declarado.
(& PUNTERO).
Ejemplo:
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define NULL 0
typedef struct{
char nombre[20];
int num;
}cliente;
void main(void) {
FILE *fichero;
cliente aux;
if ( (fichero=fopen("ejemplo.dat","r"))==NULL)
printf("\nError en la apertura del fichero");
else {
fread(&aux, sizeof(cliente), 1, fichero);
while(!feof(fichero)) {
printf("\n\nEl nombre es: %s", aux.nombre);
printf("\nEl numero es: %d", aux.num);
fread(&aux, sizeof(cliente), 1, fichero);
}
}
fclose(fichero);
}
la funcion fread() devuelve el numero de bytes leidos, por lo que se puede utilizar el valor esperado para saber si ha existido algun error(si se ha producido algun error, el numero sera menor de lo esperado.
El tamaño de los elementos del fichero sera lo que se pase en la variable en SIZE OF…., y la variable numero inidicara el numero de registros del fichero
Por su parte en la funcion FWRITE( ) dado un registro indicado por el puntero(&PUNTERO), escribe todos los bytes de sus elementos en el fichero indicado inidicado por FILE* NOMBRE DEL FICHERO.
El numero total de bytes escritos en el archivo sera igual al tamaño de cada elemento (SIZE OF (TIPO DE DATO)) por el numero de elementos(NUMERO)
La funcion FWRITE( ) devuelve el numero de elementos ecritos en el fichero.
De nuevo esto se puede utilizar para saber si ha habido un error.
Ejemplo:
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define NULL 0
typedef struct{
char nombre[20];
int num;
}cliente;
void main(void) {
FILE *fichero;
cliente aux;
int i;
if ( (fichero=fopen("ejemplo.dat","w"))==NULL)
printf("\nError en la apertura del fichero");
else {
for(i=0;i<4;i++) {
printf("\nNombre: ");
scanf(" %[^\n]", &aux.nombre);
printf("\nNumero: ");
scanf("%d", &aux.num);
fwrite(&aux, sizeof(cliente), 1, fichero);
}
}
fclose(fichero);
}
PRACTICAS DE PROGRAMACION
-
elaborar un programa que codifique una linea de texto de a lo sumo 100caracteres usando para ello una clave basada en una secuencia de numeros
la linea codificada se obtiene del siguiente modo: para cada caracter de la linea de origen se obtiene la suma de su codigo ascii con uno de los numeros que componen la clave se halla el resto de dividir el resultado entre 256.
y este resultado es el codigo asccii del nuevo caracter. para el 1 caracter se coge el primer numero y asi sucesivamente . la clave se pide por teclado y se termina cuando se meta un cero.
#include<stdio.h>
#define max 100
#include<string.h>
#include<ctype.h>// biblioteca de toascii
void suma(int ascii[],int numero[], int metidos, int longitud, int
resto[])
{
int i,suma,j=0;
for(i=0;i<longitud;i++)
{
suma=ascii[i]+numero[j];
resto[i]=suma%256;
printf("el resultado es %d\n",resto[i]);
if(j==metidos-1)
{
j=0;
}
else
{
j++;
}
}
return;
}
void main()
{
char linea[max];//array que contiene el texto metido.
int numero[max];//array que contiene la clave
int ascii[max];
int i=0,longitud=0,variable,resultado,caracter[max]; //caracter es el
nuevo numero
int metidos=0;
printf("dime el texto a inroducir\n");
gets(linea);
longitud=strlen(linea);
linea[longitud]='\0';
do
{
printf("dame un numero\n");
scanf("%d",&variable);
if (variable!=0)
{
numero[i]=variable;
metidos=metidos+1;
i=i+1;
}
}while(variable!=0);
for(i=0;i<metidos;i++)
{
printf("%d",numero[i]);
}
for(i=0;i<longitud;i++)
{
resultado=toascii(linea[i]);
ascii[i]=resultado;
printf("el numero ascii correspondiente a %c:
%d\n",linea[i],ascii[i]);
}
suma(ascii,numero,metidos,longitud,caracter);
for(i=0;i<longitud;i++)
{
printf("%c",caracter[i]);
}
}
-
Programa en el cual se declare una tabla de diez por diez en la cual hay numeros enteros . lo que hay que hacer es pedir un numero y una posicion a cambiar y cambiar los numeros colindantes al cambiado por el nuevo.
#include <stdio.h>
#define LADO 10
void rellenar (int (*foto)[LADO], int a, int b, int nuevo)
{
int antiguo;
antiguo=*(*(foto+a)+b);
*(*(foto+a)+b)=nuevo;
if (b+1<LADO && nuevo!=antiguo)
{
if (*(*(foto+a)+(b+1))==antiguo)
{
rellenar (foto, a, b+1, nuevo);
*(*(foto+a)+(b+1))=nuevo;
}
}
if (a+1<LADO && nuevo!=antiguo)
{
if (*(*(foto+a+1)+b)==antiguo)
{
rellenar (foto, a+1, b, nuevo);
*(*(foto+a+1)+b)=nuevo;
}
}
if (b-1>=0 && nuevo!=antiguo)
{
if (*(*(foto+a)+(b-1))==antiguo) {
rellenar (foto, a, b-1, nuevo);
*(*(foto+a)+(b-1))=nuevo;
}
}
if (a-1>=0 && nuevo!=antiguo)
{
if (*(*(foto+a-1)+b)==antiguo)
{
rellenar (foto, a-1, b, nuevo);
*(*(foto+a-1)+b)=nuevo;
}
}
return;
}
void imprime (int (*foto)[LADO])
{
int i, j;
for (i=0; i<LADO; i++)
{
for (j=0; j<LADO; j++)
{
printf ("%d ", *(*(foto+i)+j) );
}
printf ("\n\n");
}
return;
}
void llena (int (*foto)[LADO])
{
int i, j;
printf ("VAMOS A INTRODUCIR LOS VALORES ...\n\n");
for (i=0; i<LADO; i++)
{
for (j=0; j<LADO; j++)
{
printf ("VALOR (%d,%d): ", i+1, j+1);
scanf ("%d", *(foto+i)+j);
}
}
return;
}
void main ()
{
int (*foto)[LADO];
int nuevo, a, b;
clrscr ();
foto=(int*) malloc (LADO*LADO*sizeof(int));
llena (foto);
clrscr ();
printf ("INTRODUCE EL NUEVO VALOR: ");
scanf ("%d", &nuevo);
do
{
printf ("INTRODUCE LA POSICIàN A CAMBIAR: ");
scanf ("%d %d", &a, &b);
a-=1;
b-=1;
} while (a<0 || b<0 || a>9 || b>9);
rellenar (foto, a, b, nuevo);
imprime (foto);
getch ();
}
-
Programa anterior pero en color
#include <stdio.h>
#define LADO 10
void rellenar (int (*foto)[LADO], int a, int b, int nuevo)
{
int antiguo;
antiguo=*(*(foto+a)+b);
*(*(foto+a)+b)=nuevo;
if (b+1<LADO && nuevo!=antiguo)
{
if (*(*(foto+a)+(b+1))==antiguo)
{
rellenar (foto, a, b+1, nuevo);
*(*(foto+a)+(b+1))=nuevo;
}
}
if (a+1<LADO && nuevo!=antiguo)
{
if (*(*(foto+a+1)+b)==antiguo)
{
rellenar (foto, a+1, b, nuevo);
*(*(foto+a+1)+b)=nuevo;
}
}
if (b-1>=0 && nuevo!=antiguo)
{
if (*(*(foto+a)+(b-1))==antiguo)
{
rellenar (foto, a, b-1, nuevo);
*(*(foto+a)+(b-1))=nuevo;
}
}
if (a-1>=0 && nuevo!=antiguo)
{
if (*(*(foto+a-1)+b)==antiguo)
{
rellenar (foto, a-1, b, nuevo);
*(*(foto+a-1)+b)=nuevo;
}
}
return;
}
void imprime (int (*foto)[LADO])
{
int i, j;
for (i=0; i<LADO; i++)
{
for (j=0; j<LADO; j++)
{
if ( *(*(foto+i)+j)==1 )
{
textcolor (1);
cprintf ("ÛÛ");
}
else if (*(*(foto+i)+j)==2 )
{
textcolor (2);
cprintf ("ÛÛ");
}
else if (*(*(foto+i)+j)==3 )
{
textcolor (3);
cprintf ("ÛÛ");
}
else if (*(*(foto+i)+j)==4 )
{
textcolor (4);
cprintf ("ÛÛ");
} else if (*(*(foto+i)+j)==5 ) {
textcolor (5);
cprintf ("ÛÛ");
} else if (*(*(foto+i)+j)==6 ) {
textcolor (6);
cprintf ("ÛÛ");
} else if (*(*(foto+i)+j)==7 ) {
textcolor (7);
cprintf ("ÛÛ");
}
else if (*(*(foto+i)+j)==8 ) {
textcolor (8);
cprintf ("ÛÛ");
} else if (*(*(foto+i)+j)==9 ) {
textcolor (9);
cprintf ("ÛÛ");
} else if (*(*(foto+i)+j)==10 ) {
textcolor (10);
cprintf ("ÛÛ");
} else if (*(*(foto+i)+j)==11 ) {
textcolor (11);
cprintf ("ÛÛ");
} else if (*(*(foto+i)+j)==12 ) {
textcolor (12);
cprintf ("ÛÛ");
} else if (*(*(foto+i)+j)==13 ) {
textcolor (13);
cprintf ("ÛÛ");
} else if (*(*(foto+i)+j)==14 ) {
textcolor (14);
cprintf ("ÛÛ");
} else if (*(*(foto+i)+j)==15 ) {
textcolor (15);
cprintf ("ÛÛ");
} else if (*(*(foto+i)+j)==0 ) {
textcolor (0);
cprintf ("ÛÛ");
}
}
printf ("\n\r");
}
return;
}
void llena (int (*foto)[LADO])
{
int i, j;
printf ("VAMOS A INTRODUCIR LOS VALORES ...\n\n");
for (i=0; i<LADO; i++)
{
for (j=0; j<LADO; j++)
{
do {
printf ("VALOR (%d,%d): ", i+1, j+1);
scanf ("%d", *(foto+i)+j);
} while (*(*(foto+i)+j)>15 || *(*(foto+i)+j)<0);
}
}
return;
}
void main ()
{
int (*foto)[LADO];
int nuevo, a, b;
clrscr ();
foto=(int*) malloc (10*10*sizeof(int));
llena (foto);
clrscr ();
do {
printf ("INTRODUCE EL NUEVO VALOR: ");
scanf ("%d", &nuevo);
} while (nuevo<0 || nuevo>15);
do {
printf ("INTRODUCE LA POSICIàN A CAMBIAR: ");
scanf ("%d %d", &a, &b);
a-=1;
b-=1;
} while (a<0 || b<0 || a>9 || b>9);
rellenar (foto, a, b, nuevo);
imprime (foto);
getch ();
}
-
practica 2 hecha por el profesor
#include <stdio.h>
#include <malloc.h>
void rellenar(int (*foto)[10], int c, int f, int nuevo_color)
{
int actual;
actual= *(*(foto+f)+c);
*(*(foto+f)+c)=nuevo_color;
if (f!=1) {
if ( *(*(foto+f-1)+c)==actual )
rellenar(foto, c, f-1, nuevo_color);
}
if (f!=10) {
if ( *(*(foto+f+1)+c)==actual )
rellenar(foto, c, f+1, nuevo_color);
}
if (c!=1) {
if ( *(*(foto+f)+c-1)==actual )
rellenar(foto, c-1, f, nuevo_color);
}
if (c!=1) {
if ( *(*(foto+f)+c+1)==actual )
rellenar(foto, c+1, f, nuevo_color);
}
return;
}
void llena(int (*foto)[10])
{
int i, j;
for(i=0;i<10;i++) {
for(j=0;j<10;j++) {
printf("\nElemento %d, %d", i+1, j+1);
scanf("%d", *(foto+i)+j);
}
}
return;
}
void imprime(int (*foto)[10])
{
int i, j;
printf("\n\n");
for(i=0;i<10;i++) {
for(j=0;j<10;j++) {
printf("%d", *(*(foto+i)+j));
}
printf("\n");
}
return;
}
void main(void)
{
int (*foto)[10], nuevo_color, fila, columna;
foto=(int *)malloc(10*10*sizeof(int));
llena(foto);
printf("\nIntroduce el nuevo_color: ");
scanf("%d", &nuevo_color);
printf("\nIntroduce la posicion a tratar: ");
scanf("%d %d", &fila, &columna);
rellenar(foto, columna, fila, nuevo_color);
imprime(foto);
}
-
practica 1 hecha por el profesor
#include <stdio.h>
#include <ctype.h>
#define MAX 100
char trata(char origen, int clave)
{
int suma, resto;
suma= toascii(origen) + clave;
resto=(suma%256);
return(resto);
}
void main(void)
{
char linea[100];
int clave[MAX], i=0, j=0, leido, introducidos=0;
printf("\Introduce la linea a tratar:\n");
scanf(" %[^\n]", &linea);
do {
printf("\nIntroduce el valor %d de la clave: ", introducidos);
scanf("%d", &leido);
if (leido!=0) {
clave[introducidos]=leido;
introducidos+=1;
}
}while (leido!=0);
while (linea[i]!='\0') {
linea[i]=trata(linea[i], clave[j]);
if (j+1==introducidos) j=0;
else j+=1;
i+=1;
}
printf("\nLinea codificada:\n");
printf("%s", linea);
}
-
practica 1 otra forma de hacerlo
#include<stdio.h>
#define max 100
#include<string.h>
#include<ctype.h>// biblioteca de toascii
void suma(int ascii[],int numero[], int metidos, int longitud, int resto[])
{
int i,suma,j=0;
for(i=0;i<longitud;i++)
{
suma=ascii[i]+numero[j];
resto[i]=suma%256;
printf("\nel codigo nuevo es: %d",resto[i]);
if(j==metidos-1)
{
j=0;
}
else
{
j++;
}
}
return;
}
void main()
{
char linea[max];//array que contiene el texto metido.
int numero[max];//array que contiene la clave
int ascii[max];
int i=0,longitud=0,variable,resultado,caracter[max];//caracter es el nuevo numero
int metidos=0;
printf("dime el texto a inroducir\n");
gets(linea);
longitud=strlen(linea);
linea[longitud]='\0';
do
{
printf("dame un numero\n");
scanf("%d",&variable);
if (variable!=0)
{
numero[i]=variable;
metidos=metidos+1;
i=i+1;
}
}while(variable!=0);
printf("el texto introducido es:%s\n",linea);
printf("la clave es:");
for(i=0;i<metidos;i++)
{
printf("%d",numero[i]);
}
for(i=0;i<longitud;i++)
{
resultado=toascii(linea[i]);
ascii[i]=resultado;
printf("\nel numero ascii correspondiente a %c:
%d",linea[i],ascii[i]);
}
suma(ascii,numero,metidos,longitud,caracter);
printf(" \nel nuevo texto es:");
for(i=0;i<longitud;i++)
{
printf("%c",caracter[i]);
}
}
0 int tabla [3][4];
1
2
Descargar
| Enviado por: | Abel |
| Idioma: | castellano |
| País: | España |
Todos los derechos reservados.