Material iii parcial

Programación en C
PUNTEROS
Programación en C 1

Punteros
• Las variables de tipo puntero representan
direcciones donde almacenar valores. Es
importante diferenciar entre puntero (espacio
de memoria donde se almacena la dirección) y
la propia dirección apuntada por el puntero (su
valor).
• Se declaran con un asterisco delante del
identificador de la variable:
int *px,y; /* px es un puntero a entero e y
un entero */

• La memoria es un conjunto de celdas contiguas donde se almacenan datos.
• La unidad de memoria más pequeña es el bit.
• El byte es un conjunto de 8 bits. Unidad de memoria.
• El lugar (ubicación) de cada byte es único y es su dirección.
• Si los bytes son consecutivos la dirección se ira incrementando secuencialmente.
• Cada celda tiene dos valores asociados: Dirección y Contenido.
Memoria.
1 2 3 4 5 6 7 8 9 A B C D E F
1 0 1 1 0 0 1 1
171 186 137 99
10101011 10111010 10001001 1100011
Dirección:0xC100
Dirección +1: 0xC101
Dirección + 3: 0xC103
Celda: Valor Decimal
Celda: Valor Binario

Variables
• Una variable es una porción de memoria identificada por un nombre.
• El tipo de dato define su representación binaria y longitud.
• Tiene tres valores asociados: Nombre, Contenido y Dirección.
• Declaramos: “int n=1523, m=121;”
• Contenido:
– n  1523
– m  121
• Dirección:
– &n  C102
– &m  C100
• Es contenido binario se codifica (bits) de acuerdo al tipo de variable.
0000000 01111001 00000101 11110011
Dirección: C100 Dirección: C102
Valor: 121 Valor: 1523

Tipos de Variables
• El tipo de variable establece:
– Rango de valores que maneja.
– Codificación binaria del dato.
– Cantidad de memoria requerida.
• En todos los casos la dirección de almacenaje es “&variable”.
Declaración Bytes Valor en Memoria Hexa Valor en Memoria Binario
char c = ‘X’; 1 58 1011000
char w[ ] = “hola”; 4+1 68 6F 6C 61 00 01101000 01101111 01101100
01100001 00000000
int n[5] = {555,444,333,222,111} 5x2=10 02 2B 01 BC 01 4D 00 DE 00 6F 00000010 00101011 00000001 10111100
00000001 01001101 00000000 11011110
00000000 01101111
long l[3] = {100,200,300} 3x4=12 00 00 00 64 00 00 00 C8 00 00 01 2C 00000000 00000000 00000000 01100100
00000000 00000000 00000000 11001000
00000000 00000000 00000001 00101100
float f = 3.141592 4 40 49 0F D8 1000000010010010000111111011000

6
Un puntero es un objeto que apunta a otro objeto. Es decir,
una variable cuyo valor es la dirección de memoria de otra
variable.
Las direcciones de memoria dependen de la arquitectura
del ordenador y de la gestión que el sistema operativo haga
de ella.
Punteros

7
No hay que confundir una dirección de memoria con el
contenido de esa dirección de memoria.
int x = 25;
... ... 25 ... ... ... ...
Dirección 1502 1504 1506 1508
La dirección de la variable x (&x) es 1502
El contenido de la variable x es 25
Punteros

Punteros
• Los gestión de punteros admite dos operadores
básicos:
– Si px es un puntero (dirección): *px es el contenido
del puntero (el valor almacenado en la dirección).
– Si x es una variable: &x es la dirección de memoria
donde está almacenada la variable.

10
Declaración
Los punteros se declaran con un asterisco, de esta forma:
tipo * variable;
Por ejemplo:
int* puntero;
Se dice que la variable puntero es un puntero a enteros (apunta a un entero).
Asignación
El valor que puede adquirir un puntero es, por ejemplo, la dirección de una variable.
El operador & devuelve la dirección de una variable:
puntero = &variable;
Punteros

Punteros
int main()
{
int *px,y=3;
px=&y;
/* px apunta a y */
*px=5;
/* y vale 5 */
}
Dirección
px-> 35:
y -> 39:
Contenido Gráfica
? ? ? ?
0 0 0 3
?
px
3
y
px-> 35:
y -> 39:
0 0 0 39
0 0 0 3
39
3
y
px
px-> 35:
y -> 39:
0 0 0 39
0 0 0 5
39
5
y
px

Punteros
• Un puntero es una variable cuyo contenido es una dirección.
• Como todas las variable tiene nombre, contenido y dirección.
• Un puntero “apunta a”: un dato, un array, un objeto, una función, etc.
• “int n;” declara una variable entera (16 bits / 2 bytes)
• “int *j;” declara un puntero tipo entero (solo almacena direcciones).
• “j” contiene una dirección donde comienza un entero.
• “*j” valor entero almacenado en la dirección apuntada por “j” .
• n  contenido=“valor del entero” j  contenido=“valor de la dirección”.
• &n  dirección del entero en “n” *j  contenido en la dirección de “j”.
Valor *j=n  40j0xA010
Dirección: &j0xF234
Dirección: j  &n 0xA010
Lugar: 2 byte donde esta
almacenado j
Lugar: 2 byte donde esta
almacenado n
Representamos “int n=40, *j=&n;” suponemos que se almacenan:
n en la dirección 0xA010 y j en la dirección 0xF234

¿Arreglos o arrays?
Un arreglo (array) es una colección de datos del
mismo tipo, que se almacenan en posiciones
consecutivas de memoria y reciben un nombre
común.

Arreglos
Para referirse a un determinado elemento de un
array se deberá utilizar un índice, que
especifique su posición relativa en el array. Un
arreglo es una colección finita, homogénea y
ordenada de elementos.

ARREGLOS
•Finita:Todo arreglo tiene un límite; es
decir,debe determinarse cuál será el número
máximo de elementos que podrán formar parte
del arreglo.
•Homogénea: Todos los elementos del arreglo
deben ser del mismo tipo.
•Ordenada: Se puede determinar cuál es el
primer elemento, el segundo, el tercero,.... y el
n-ésimo elmento.

ARREGLOS
Los arreglos se clasifican de acuerdo con el
número de dimensiones que tienen. Así se
tienen los:
•Unidimensionales (vectores)
•Bidimensionales (tablas o matrices)
•Multidimensionales (tres o más dimensiones)

Unidimensionales y bidimensionales

ARREGLOS O ARRAY
VECTORES
Es un array unidimensional, es decir, solo usa un
índice para referenciar a cada uno de los
elementos.
Se declara:
tipo nombre [tamaño];
23

EJEMPLO
int num[100]; /*Arreglo de tipo entero compuesto de 100
posiciones*/
char nom[80]; /*Texto de 80 caracteres*/
float x[12]; /*arreglo de 12 elementos punto flotantes */
25

Indexación de arrays
A diferencia de otros lenguajes los arrays en C
comienzan por el elemento 0 y terminan en el
n-1.
int a[6];
a[0]=23;
a[3]=a[0]+5;
for(i=0;i<6;i++) printf(“%d”,a[i]);
23 28a
a[0] a[1] a[2] a[3] a[4] a[5]

EJERCICIO
Lea un vector de 10 posiciones, luego determine si la primera posición es divisible para 3, si la
quinta posición es numero primo y si la ultima posición es mayor que 50.
29

EJERCICIO
MÁXIMO ELEMENTO DE UN CONJUNTO DE NÚMEROS Y SU UBICACION.
Este programa calcula el máximo entre un conjunto de números enteros. Para ello se sigue el siguiente
algoritmo: se crea una variable llamada mayor, a la que se da inicialmente el valor de arr[0]. Luego se
recorren paso a paso todos los elementos del vector, comparando el valor almacenado en la posición
considerada del vector con el valor de la variable mayor. Si el valor de la posición considerada del vector
es mayor que mayor, entonces se copia (se sustituye el valor) en la variable mayor este valor. De esta
forma, una vez recorrido todo el vector, la variable mayor contendrá el máximo valor.

Strings
Los strings son los arrays de caracteres de una
dimensión. Son las cadenas de caracteres.
Definición:
char x[20],n[6]=“Chema”;
/*equivalente a
char n[5]={’C’,’h’,’e’,’m’,’a’,’0’}*/
C h e m a 0n
n[0] n[1] n[2] n[3] n[4] n[5]
Carácter
nulo

Asignación de Strings
La asignación de strings por medio del operador
(=) sólo es posible en la declaración.
Ejemplo:
char n[5]=“Chema”; /* Correcto */
n=“Otro nombre”; /* Error: no es
declaración */
Para las operaciones sobre strings se utilizan
diferentes funciones de librería. Por ejemplo,
strlen() calcula el tamaño del string
(número de caracteres).

Biblioteca de manejo de cadenas (string.h)
La biblioteca <string.h> contiene un conjunto de funciones para manipular cadenas: copiar, cambiar caracteres,
comparar cadenas, etc.
Las funciones más elementales son:
strcpy ( c1, c2 ); Copia c2 en c1
strcat ( c1, c2 ); Añade c2 al final de c1
int strlen ( cadena ); Devuelve la longitud de la cadena
int strcmp ( c1, c2 ); Devuelve cero si c1 es igual a c2;
Ejemplo:
#include <stdio.h>
#include <string.h>
char completo [80];
char nombre[32] = "Pedro";
char apellidos [32] = "Medario Arenas";
Void main()
{
/* Construye el nombre completo */
strcpy ( completo, nombre ); /* completo <- "Pedro" */
strcat ( completo, " "); /* completo <- "Pedro " */
strcat ( completo, apellidos ); /* completo <- "Pedro
Medario Arenas" */
printf ( "El nombre completo es %sn", completo );
}

Esta copia es destructiva, o sea, que todos los caracteres que estaban en la cadena destino desaparecen, aunque la cadena
destino fuera más larga que la cadena fuente .La cadena destino se pone como primer argumento de la función y la
cadena fuente como segundo.
#include<stdio.h>
#include<string.h>
int main()
{
char texto1[]="corta";
char texto2[]="mediana";
char texto3[]="larguisima";
strcpy(texto2,texto1);
printf("%sn",texto2);
strcpy(texto2,texto3);
getch();
return 0;
}
Strcpy (cadenad , cadenaf)
copia una cadena (fuente) en otra (destino) sin destruir ésta, es decir, que copia una
cadena detrás de la otra esta función es conocida como
strcat ( c1, c2 );
#include<stdio.h>
#include<string.h>
int main()
{
char texto1[]="Don Pepito";
char texto2[]=" y ";
char texto3[]="Don Jose";printf("%sn",texto1);
strcat(texto1,texto2);
strcat(texto1,texto3);
getchar();
return 0;
}

strcmp: La función strcmp recibe dos cadenas, a y b, devuelve un entero. El entero que resulta de efectuar la llamada
strcmp(a, b) codifica el resultado de la comparación:
• es menor que cero si la cadena a es menor que b,
• es 0 si la cadena a es igual que b, y
• es mayor que cero si la cadena a es mayor que b.
Strcmp (a,b)
#include <stdio.h>
#include <string.h>
int main()
{
char s1[6] = "Abeja";
char s2[6] = "abeja";
int i;
printf( "s1=%st", s1 );
printf( "s2=%sn", s2 );
i = strcmp( s1, s2 );
printf( "s1 es " );
if( i < 0 ) printf( "menor que" );
else if( i > 0 ) printf( "mayor que" );
else printf( "igual a" );
printf( " s2n" );
return 0;
}
Otras Funciones útiles para operar cadenas de caracteres.
En ctype.h se encuentran unas funciones que permiten hacer cómodamente preguntas acerca de
los caracteres, como si son mayúsculas, minúsculas, dígitos, etc:
isalnum(caracter): devuelve cierto (un entero cualquiera distinto de cero) si caracter es una letra
o dígito, y falso (el valor entero 0) en caso contrario.
isalpha(caracter): devuelve cierto si caracter es una letra, y falso en caso contrario.
isblank(caracter): devuelve cierto si caracter es un espacio en blanco o un tabulador.
isdigit(caracter) devuelve cierto si caracter es un digito, y falso en caso contrario.
isspace(caracter): devuelve cierto si caracter es un espacio en blanco, un salto de línea, un
retorno de carro, un tabulador, etc., y falso en caso contrario.
islower(caracter): devuelve cierto si caracter es una letra minúscula, y falso en caso contrario.
isupper(caracter): devuelve cierto si caracter es una letra mayúscula, y falso en caso contrario.
toupper(caracter): devuelve la mayúscula asociada a caracter, si la tiene; si no, devuelve el mismo
caracter.
tolower(caracter): devuelve la minúscula asociada a caracter, si la tiene; si no, devuelve el mismo
caracter.

CADENAS O S TRINGS
Los strings o cadenas son arreglos unidimensionales de tipo char. Por convención, un string en
C se termina con el carácter nulo ‘0’. Por ejemplo, si tenemos char a[5], el elemento a[4] es el
‘0’.Las constantes de strings se escriben entre comillas; por ejemplo, ``abc'' es un arreglo
decaracteres de tamaño 4, donde el último elemento es el carácter nulo ‘0’.
Inicializacion de String:
char arreglo[5]={‘h’,’o’,’l’,’a’,’0’}
Crear un programa donde ingreses un nombre y muestre la longitud del nombre ingresado. Entrada: Una
cadena de caracteres (nombre)Salida: El largo del nombre (Note que también se cuentan los ‘ ‘)
Restricciones: ninguna
#include<stdio.h>
main()
{
char nombre[20];
int i,largo;
printf("Ingrese su nombre n");
gets(nombre);
for(i=0,largo=0; nombre[i]!='0';i++)
largo++;
printf("El largo de su nombre es %dn",largo);
}

Cree un programa que invierta un nombre.
Entrada: Una cadena de caracteres (nombre)
Salida: Una cadena de caracteres invertida (nombre invertido)
Restricciones: ninguna
#include<stdio.h>
main()
{
char nombre[20];
char aux[20];
int i,j,largo;
printf("Ingrese su nombre n");
gets(nombre);
for(i=0,largo=0; nombre[i]!='0';i++)
largo++;
for(i=largo-1,j=0; i>=0 ; i--,j++)
aux[j]=nombre[largo];
aux[j]=’0’;
printf("El nombre invertido es %sn",aux);
}

OPERACIONES CON VECTORES O
LISTAS
1. ORDENACION POR SELECCION ()
2. ORDENACION POR INSERCION ()
3. ORDENACION POR INTERCAMBIO DIRECTO ()
4. ORDENACION POR INTERCAMBIO DIRECTO MEJORADO
Explicacion teórica del método
Elaboración del algoritmo
Implementacion en C ++
Prueba de Escritorio

ORDENAMIENTO POR SELECCION
Algoritmo de ordenamiento por Selección (Selection Sort en inglés): Consiste en encontrar el menor de todos los
elementos del arreglo o vector e intercambiarlo con el que está en la primera posición. Luego el segundo mas
pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere O(n2) comparaciones e intercambios
para ordenar una secuencia de elementos.

Ordenamiento por inserción
El método de inserción directa consiste en insertar un elemento del arreglo en la
parte izquierda del mismo que ya se encuentra ordenada. Este proceso se repite
desde el segundo hasta el n-esimo elemento.
#include<stdio.h>
#include<conio.h>
int a[4]={40,10,70,20};
int n=4;
int i,j,aux;
main(){
for(i=0;i<n;i++)
{
j=i;
aux=a[i];
while(j>0 && aux<a[j-1])
{
a[j]=a[j-1];
j--;
}
a[j]=aux;
}
for(i=0;i<4;i++)
printf("%dt",a[i]);
}

ORDENACION POR INTERCAMBIO DIRECTO
El método de ordenación por burbuja se basa
en comparaciones sucesivas de dos elementos
consecutivos y realizar un intercambio entre los
elementos hasta que queden ordenados.
int v[]={6,5,3,1,8,7,2,4};
int j,i, aux;
// Ordenación
for(i=0; i<8; i++){
for(j=0; j<7; j++){
// Intercambiar los elementos
if(v[j] > v[j+1]){
aux=v[j];
v[j]=v[j+1];
v[j+1]=aux;
}
}
}

Búsqueda lineal
La búsqueda lineal probablemente es sencilla de implementar e intuitiva. Básicamente
consiste en buscar de manera secuencial un elemento, es decir, preguntar si el
elemento buscado es igual al primero, segundo, tercero y así sucesivamente hasta
encontrar el deseado.
cout << "Busqueda lineal -> Ingresa el elemento a buscar: ";
cin >> elemento;
for (int i = 0; i< max; i++)
{
if (elemento == vector[i])
{
cout << "Se encuentra en la posicion " << i + 1 << endl;
}

Arreglos Bidimensionales
• Un arreglo bidimensional es un array de arrays
unidimensionales.
• Se puede visualizar a un arreglo bidimensional
como una matriz con filas y columnas. El
primer índice indica la fila y el segundo indica
la columna.

• Los arreglos de dos dimensiones se declaran
de acuerdo al esquema
• tipo variable[filas][columnas];
• Ejemplo
• int a[5][4];
a[0][0] a[0][1] a[0][2] a[0][3]
a[1][0] a[1][1] a[1][2] a[1][3]
a[2][0] a[2][1] a[2][2] a[2][3]
a[3][0] a[3][1] a[3][2] a[3][3]
a[4][0] a[4][1] a[4][2] a[4][3]
Declaración

1
Arreglos Bidimensionales
• Una matriz bidimensional tiene la forma sigui
ente:
a11 a12 ............ a1n
a21 a22 ............ a2n
.....................
am1 am2 ............ amn
• Para acceder al dato aij se hace de la
manera siguiente:
c=a[i][j];

Inicialización
• int a[5][4] =
{{2,3,4,2},{2,0,6,1},{3,5,5,0},{2,2,
1,1},{3,2,5,6}};
2 3 4 2
2 0 6 1
3 5 5 0
2 2 1 1
3 2 5 6

int a[5][4] = {{2,3},{1},
{3,5,5,0},{2},{3}};
2 3 0 0
1 0 0 0
3 5 5 0
2 0 0 0
3 0 0 0
Inicialización

Ejemplo 1
• #include <conio.h>
• #include <stdio.h>
• void main()
• {
• int matriz[5][5], contador=0;
• // Asigno un contador a cada elemento de la matriz
• for(int i=0;i<5;i++)
• {
• for(int j=0;j<5;j++)
• {
• matriz[i][j]=contador++;
• }
• }
• printf("Impresión de la matriz...n");
• for( i=0;i<5;i++)
• {
• {
• printf("%dt",matriz[i][j]);
• }
• printf("n");
• }
• printf("Gracias");
• }

Ejemplo 2
• #include <conio.h>
• #include <stdio.h>
• void main()
• {
• //Inicializa una matriz. Al igual que los arreglos la matriz puede tomar valores iniciales
• //y no necesariamente deben inicializarse todos los elementos
• int matriz[5][5]={{1,10,20},{40,17,25, 18, 19},{18,19,20, 27},{1}};
•
• printf("Impresión de la matrizn");
• for(int i=0;i<5;i++)
• {
• {
• printf("%dt",matriz[i][j]);
• }
• printf("n");
• }
• printf("Gracias");
• }

Programa que lee una matriz de 3*3 y determina la suma de
cada una de las filas y almacena en un vector llamado suma.
#include <stdio.h>
#include <conio.h>
#define F 6
#define C 6
main()
{
int matriz[F][C], i,j, vector [F]={0,0,0,0,0,0};
for(i=0; i<F; i++)
for(j=0; j<C; j++)
{ printf("Ingrese el elemento F=%d y Columna=%d de la matriz:n", i,j);
scanf("%d", &matriz[i][j]);
vector[i]=vector[i]+matriz[i][j];
}
printf("La Matriz generada es:nn");
for(i=0; i<F; i++)
{
for(j=0; j<C; j++)
{
printf("*%d*", matriz[i][j]);
}
printf("n");
}
printf("Y el vector suma de las filas es:nn");
for(i=0; i<F; i++)
printf("%dt", vector[i]);
getch();
return 0;
}
51

Ejemplo
#include<iostream>
#include <stdio.h>
using namespace std;
main()
{
int est,i;
cout<<"Ingrese No de estudiantest";
cin>>est;
char nombre[est][10],apellido[est][10];
for(i=0;i<est;i++)
{
cout<<"Estudiantet"<<(i+1)<<endl;
cout<<"Ingrese el Nombre:t";
cin>>(nombre[i]);
cout<<"Ingrese el Apellido:t";
cin>>(apellido[i]);
}
cout<<"Carga realizada"<<endl;
for(i=0;i<est;i++)
{
cout<<"Estudiante "<<(i+1)<<"t"<<nombre[i]<<" "<<apellido[i]<<endl;
}
}
En el siguiente ejemplo se utilizan dos listas (nombres y apellidos) con capacidad de almacenar 3 cadenas de
30 caracteres cada una.

55
Funciones
• Definición:
– Las funciones son los bloques de construcción
básicos de C/C++. Dentro de ellas se da toda la
actividad del programa.
• Criterios para crearlas:
– Se usa la estrategia de “Dividir y Conquistar”, en
otras palabras, es realizar la partición de la tarea
en subtareas más fáciles de abordar.
– Todo problema se puede resolver con funciones o
sin ellas, pero su uso adecuado hace que el
programa sea más eficiente, fácil de leer y probar.

56
Funciones: ventajas
1.- Facilita el diseño descendente.
2.- Los procedimientos dentro de ellas se pueden
ejecutar varias veces.
3.- Facilita la división de tareas.
4.- Se pueden probar individualmente
5.- Con funciones apropiadamente diseñadas, es
posible ignorar como se realiza una tarea,
sabiendo qué es lo que hacen.

57
La sentencia return
– Fuerza la salida inmediata de la función en
que se encuentra.
– Se puede utilizar para devolver un valor.

58
Funciones
– Las funciones terminan su ejecución ya
sea a través de la ejecución de la última
instrucción o utilizando la sentencia return.
– Un función puede retornar valor sólo
cuando el tipo de retorno no es void.
– Las funciones que son de tipos distintos de
void pueden ser utilizadas como
operandos en otras expresiones del
lenguaje.

59
Funciones: modos de uso
1.- Funciones diseñadas para realizar
operaciones a partir de sus argumentos
y devolver un valor basado en sus
cálculos.
2.- Funciones que no reciben
argumentos, realizan un proceso y
devuelven un valor .
3.- Funciones que no tienen argumentos
ni valor de retorno explícito, operan
sobre el entorno de variables globales o
atributos del sistema operativo.

60
Variables locales y globales
• Variables Locales:
– Se declaran dentro de la función y sólo
están disponibles durante su ejecución.
– Se crean cuando se entra en ejecución
una función y se destruyen cuando se
termina.
• Variables globales:
– Se declaran fuera de las funciones.
Pueden ser utilizadas por todas las
funciones.
– Existen durante toda la vida del programa.

ESTRUCTURA DE UNA FUNCION
Donde el tipo_de_funcion corresponde al tipo de datos que retorna ó devuelve dicha
función, la cual puede ser del tipo entero ( int ) , flotante (float), carácter (char ) etc,
además es importante aclarar que aquellas funciones que no son definidas, por defecto
son de tipo entero.
argumentos: corresponde a valores recibidos por la función, los cuales también se deben
definir de un tipo determinado, como si se tratase de una definición de variable común y
corriente,
cabe destacar además que no necesariamente una función debe recibir un valor, si no que
esta puede estar vacía.

ESTRUCTURA DE LOS ARGUMENTOS
Cuerpo de la función: Corresponde al código fuente que se encargará de realizar el proceso, aquí se
deberán declarar variables si fuese necesario, dichas variables son denominadas variables locales porque
pertenecen a esa función y sólo existen cuando el compilador toma dicha función, dejando de existir cuando
el compilador termina de ejecutar dichas líneas de código. Existen las variables globales, definidas en el
programa principal, antes del main(), las cuales pueden ser utilizadas en cualquier parte del programa,
incluyendo las funciones.
return(variable ó valor): Corresponde al valor que retornará dicha función donde halla sido llamada, es
importante destacar que una variable ó valor único. Más adelante veremos como retornar variables que
tengan asociados más de un valor, por lo que por el momento sólo nos quedaremos con la proposición
inicial.
Algunas veces no necesitaremos que las funciones nos retornen un valor, por lo que podremos omitir esta
sentencia.

Ejemplo Crear un programa utilizando funciones donde se sumen dos números. En este
programa existen variables globales (x e y) y variables locales (result en el cuerpo del
programa principal; y las variables a y b en la función suma. Las variables locales sólo tienen
existencia durante la ejecución de la respectiva función. Pueden existir variables locales con
el mismo nombre en distintas funciones las cuales estarán haciendo referencia a posiciones
distintas de memoria.

Ejemplo : En este ejemplo, la función imprimir_valores no retorna ninguna valor, por lo que es
denominada de tipo void.
#include<stdio.h>
void imprimir_valores(int suma)
{
printf("El resultado de la suma es %dn",suma);
}
main()
{
int a,b,result;
printf("Ingrese el primer valor n");
scanf("%d",&a);
printf("Ingrese el segundo valor n");
scanf("%d",&b);
result=a+b
imprimir_valores(result); // En este caso no se asigna a ninguna variable puesto
que no retorna un valor.
}

Ejemplo : Crear una función que entregue el número mayor de dos números.

66
Ejemplo
Construya un programa que calcule el
cuadrado de los 10 primeros números
enteros.

67
Solución
#include <stdio.h>
int cuadrado(int x){
int r;
r=x*x;
return r;
}
main(){
int i,resultado;
for (i=0;i<10;i++){
resultado = cuadrado (i);
printf("Cuadrado de %d:t%dn",i,resultado);
}
return 0;
}

68
Transferencia de Información
– por valor: copia el valor de un argumento
de la llamada en el parámetro formal de la
función. Por lo tanto, los cambios en los
parámetros de la función no afectan a las
variables que se usan en la llamada.
– por referencia: se copia la dirección del
argumento en el parámetro. Los cambios
hechos a los parámetros afectan a las
variables usadas en la llamada a la
función.

69
Ejemplo
Desarrolle una función que realiza un intercambio de
los valores entre 2 variables.

70
Solución con error ¿porqué?
#include <stdio.h>
void intercambio(int x, int y){
int temp;
temp=x;
x=y;
y=temp;
printf(“n x=%d y=%d temp=%d “,x,y,temp);
}
main(){
int a=1,b=2;
printf("a=%d b=%dn",a,b);
intercambio (a,b);
return 0;
}

Paso por referencia
El lenguaje C NO tiene paso por referencia. En su
lugar se pasa por valor la dirección de la variable a
modificar.
int reiniciar(int *a, int b)
{
*a=0; b=0;
}
int x=2,y=2;
reiniciar(&x,y); /* x valdrá 0 e y 2 */

Paso por referencia
int x=2,y=2;
reiniciar(&x,y);
int reiniciar(int *a, int b)
{
*a=0; b=0;
}
2x 2y
2x 2y
a 2b
0x 2y
a 0b

73
Solución correcta
#include <stdio.h>
void intercambio(int *x, int *y){
int temp;
temp=*x;
*x=*y;
*y=temp;
printf(“ x=%d y=%d temp=%d n“,*x,*y,temp);
}
main(){
int a=1,b=2;
intercambio (&a,&b);
printf("na=%d b=%d",a,b);
return 0;
}

void gotoxy(int x, int y)
{
COORD coord;
coord.X=x;
coord.Y=y;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),coord);
}
FUNCION GOTOXY PARA CODEBLOC

Argumentos de tipo array
Cuando un array se pasa como argumento a una
función, la última de las dimensiones no se define.
Ejemplo:
int vec[12],mat[4][4];
calcula(vec,mat);
void calcula(int v[], int m[][4])
{
...
}

Material iii parcial

Más contenido relacionado

La actualidad más candente (19)

Similar a Material iii parcial (20)

Más de Cesar Oswaldo Osorio Agualongo (20)

Último (20)

Material iii parcial

Notas del editor