FUNCIONES DEFINIDAS POR EL USUARIO (CON ENVÍO Y RETORNO DE PARÁMETROS.)

Este tipo de funciones a diferencia de las anteriores que se las declara con la palabra reservada void que significa que no retorna algún valor desde su dominio a la función main, se las define intercambiando la palabra void por el tipo de dato que queremos traer de vuelta como resultado.
Las funciones de este tipo se las define como acontinuación muestra:

Librerias
tipo_dato funcion( tipo_dato variable,tipo_dato1 variable1);
void main()
{

 tipo_dato var1,var2;
bloques de códigos

funcion(var1,var2);
}tipo_dato funcion(tipo_dato variable,tipo_dato1 variable1)

{
bloques de códigos

}

Al igual que el grafico explicativo de las Funciones Definidas por el Usuario (con envío y sin retorno de parametros) el orden de la variables de envío es el mismo.
Pero en las lineas de codigo internas a la función hay una diferencia total en cuanto a la programación ya que este tipo de funciones usa una palabra reservada en su dominio que es "return", que es la que nos permite devolver un valor resultante a la funcion principal o main.

1. #include<conio.h>
2. #include<stdio.h>
3.   int suma(int numero1,int numero2);
4.   void main()
5.   {
6.    clrscr();
7.    int n1,n2;
8.    printf("Ingrese un numero: ");
9.    scanf("%d",&n);
10.    printf("Ingrese otro numero: ");
11.    scanf("%d",&n1);
12.    printf("La suma es: %d",suma(n1,n2));
13.    getch();
14.   }
15.   int suma(int numero1,int numero2)
16.    {
17.     int s;
18.     s=numero1+numero2;
19.     return s;
20.    }

Se puede apreciar que en la función suma declaramos una variable  's' a la cual se le asigna la operación suma de numero1 y numero2 y en la siguiente linea hay un return s; que significa que el valor resultante de la suma de esos dos valores me la retornara a la función main justo cuando mande a llamar a la función suma es decir desde el printf.
El ejercicio también pudo quedar así.

1. #include<conio.h>
2. #include<stdio.h>
3.   int suma(int numero1,int numero2);
4.   void main()
5.   {
6.    clrscr();
7.    int n1,n2,s;
8.    printf("Ingrese un numero: ");
9.    scanf("%d",&n);
10.    printf("Ingrese otro numero: ");
11.    scanf("%d",&n1);
12.    s=suma(n1,n2);
13.    printf("La suma es: %d",s);
14.    getch();
15.   }
16.   int suma(int numero1,int numero2)
17.    {
18.     return numero1+numero2;
19.    }

Lo cual nos ahorra la declaración de la variable s en la función suma pero la declaramos en la función main(), y a su vez también se pudo ahorrar la declaración de la variable s en las dos funciones usando el main() del primer ejemplo y la función suma del segundo.

NOTA: No olvidar que para que nuestra función retorne un valor hay que definirla con el tipo de dato correspondiente, en este caso use un dato de tipo int dado que la suma de dos enteros me resulta otro entero.

FUNCIONES DEFINIDAS POR EL USUARIO (CON ENVÍO Y SIN RETORNO DE PARÁMETROS.)

Este tipo de funciones a diferencia de las vistas anteriormente en su declaración tienen un parámetro extra, su funcionamiento es el mismo pero al momento de llamar a la función se lo realiza poniendo el nombre de la función, y entre los paréntesis se escribe la o las variables que se desea mandar para realizar una tarea especifica, y la función al momento de receptar las variables hay que declarar nuevas variables del mismo tipo que se mandaron, pueden ser del mismo nombre o diferente.
Las Funciones con envio y sin retorno de parametros se las define de la siguiente manera:

Librerias
void funcion( tipo_dato variable,tipo_dato1 variable1);
void main()
{

 tipo_dato var1,var2;
bloques de códigos

funcion(var1,var2);
}
void funcion(tipo_dato variable,tipo_dato1 variable1)

{
bloques de códigos}

A continuación veremos un gráfico explicativo:

Se puede apreciar que las variables que se mandan desde la función principal deben tener el mismo orden y del mismo tipo a las que recibe la función.

1. #include<conio.h>
2. #include<stdio.h>
3.   void suma(int numero1,int numero2);
4.   void main()
5.   {
6.    clrscr();
7.    int n1,n2;
8.    printf("Ingrese un numero: ");
9.    scanf("%d",&n);
10.    printf("Ingrese otro numero: ");
11.    scanf("%d",&n1);
12.    suma(n1,n2);
13.    getch();
14.   }
15.   void suma(int numero1,int numero2)
16.    {
17.     int s;
18.     s=numero1+numero2;
19.     printf("La suma es: %d", s);
20.    }

Funciones definidas por el usuario (Sin envío ni retorno de parámetros.)

Este tipo de funciones son las mas sencillas de realizar ya que solo se hace la llamada desde la función principal "main()".
En este tipo de funciones y en todas no hay olvidar que si se las crea al ultimo del programa se pone el prototipo, y que si se la crea al inicio, después de las librerías no hace falta, y se las define de la siguiente manera.
Librerias
void funcion();
 void main()
{
bloques de códigos
}
void funcion()
{
bloques de códigos
}
Como se aprecia en el prototipo se ubica la primera linea de la función, pero terminada en punto y coma, cosa que no se pone en la función.
Dentro de la función definida por nosotros, se pueden declarar variables igualmente como en la función main() o en su defecto también se podría definir unas variables como globales para que puedan receptarlas tanto la función principal como la creada por nosotros, hay que tener en cuenta que para definir una función de este tipo, se usa la palabra reservada void y el nombre de la función y los paréntesis, la palabra reservada void nos indica que la funcion no retorna un parámetro, y los paréntesis en blanco porque no recibe ninguno.
Para mandar a llamar a la función se lo hace con el nombre y los paréntesis en blanco.
Un breve ejemplo veremos a continuación.

1.     #include<conio.h>
2.     #include<stdio.h>
3.     void suma();
4.     void main()
5.     {
6.      clrscr();
7.      suma();
8.      getch();
9.     }
10.     void suma()
11.      {
12.      int n,n1,s;
13.      printf("Ingrese un numero: ");
14.      scanf("%d",&n);
15.      printf("Ingrese otro numero: ");
16.      scanf("%d",&n1);
17.      s=n+n1;
18.      printf("La suma es: %d", s);
19.     }

Funciones definidas por el usuario

Vamos a entrar a un nuevo tema como lo es, funciones definidas por el usuario, esto nos indica que nosotros podemos hacer nuestras propias funciones que nos devuelvan un resultado requerido. Como ya sabemos la función principal es la main(), y dentro de su dominio podemos usar otras funciones de las que nos proporciona Borland, como la de cuadrado la de la raíz y así sucesivamente. 
Ahora veremos como crear nuestras funciones, las cuales son pequeñas secuencias de códigos que realizan específicamente una tarea.
Se las puede declarar de las siguientes maneras:

Librerías
Prototipo de la función definida por nosotros
 void main()
{
bloque de sentencias
}

Función definida por el usuario

El prototipo se refiere al la definición de la función o comunmente dicho la primera linea que conforma la librería pero terminada en punto y coma.

La otra forma de declararlas es:

Librerías
Función definida por el usuario

void main()
{

bloque de sentencias

}

A diferencia de la primera forma no hace falta de un prototipo ya que la función se la define al principio antes de la función main. 

Existen tres tipos de funciones definidas por el usuario las cuales son:

1. Sin envío ni retorno de parámetros.
2. Con envío y sin retorno de parámetros.
3. Con envío y retorno de parámetros.

Cada una de ellas se las manda a llamar o se las invoca poniendo el nombre de la función dentro de la función main(), seguida de los paréntesis, eso nunca hay que olvidar, ya que si no ponemos los paréntesis se lo tomaría como una variable más del programa.

Cadenas de Caracteres (Ejercicio 21)

En post anteriores vimos que las cadenas de caracteres se las define como una arreglo unidimensional de tipo char: char a[15];

que significa un conjunto de caracteres de tamaño 15, este tipo de dato lo vamos a estudiar de manera independiente a los demás datos.

¿Por qué? se preguntarán, pues por la razón que con este dato usamos unas funciones especiales que se las encuentran en la librería string.h, comunmente cuando queremos asignar el valor de una variable a otra, tranquilamente lo hacíamos con el simbolode asignación "=", pero en el caso de una variable que posea una cadena de caracter no es posible eso, estudiaremos brevemente unas de las funciones mas usadas.

strcpy(cadena1,cadena2);

Esta función nos permite asignar los datos de caracter2 a carcter1, sirve como el asignación para variables numéricas.

strcmp(cadena1,cadena2)==0;

Nos permite ver si una cadena de caracter es igual a otra, diferencia las mayusculas y minusculas, si queremos ver si es diferente seria strcmp(cadena1,cadena2)!=0; y se las usa como condiciones, dentro de las estructuras condicionales y repetitivas.

strcmpi(cadena1,cadena2)==0;

Realiza casi la misma función que strcmp(); pero la diferencia es que esta función no realiza diferencias entre las mayusculas y minusculas.

strlen(cadena);

Esta función permite calcular el tamaño en números enteros de la cadena.

strncat(cadena1,cadena2,num_carac);

Esta función nos permite agregarle un numero especifico de caracteres a cadena1 de cadena2 al final, num_carac es la variable numérica que controla cuantos caracteres se le va a agregar.

strncmp(cadena1,cadena2,n);

Saca comparaciones de los primeros "n" caracteres de las cadenas.

strncpy(cadena1,cadena2,n);

Copia los primeros 'n' caracteres de la cadena2 a la cadena1.

Programa 21:

Combinacion de algunas de las funciones de cadenas de caracter.

1. #include<string.h>
2. #include<stdio.h>
3. #include<conio.h>
4. void main()
5. {
6.  clrscr();
7.   char *l,*l2,*l3;
8.   int n;
9.   printf("Palabra 1: ");
10.    fflush(stdin);
11.   scanf("%[^\n]",l);
12.   printf("Palabra 2: ");
13.   fflush(stdin);
14.   scanf("%[^\n]",l2);
15.   printf("Palabra 3: ");
16.   fflush(stdin);
17.   scanf("%[^\n]",l3);
18.   printf("Numero: ");
19.   scanf("%d",&n);
20.   printf("\nstrncat\n%s",strncat(l3,l2,n));
21.   printf("\nstrlen\n%d",strlen(l));
22.   printf("\nstrncpy\n%s\n",strncpy(l,l3,n));
23.   printf("\nstrncmp\n");
24.   if(strncmp(l,l2,n)==0)
25.   printf("Igual");
26.   else
27.   printf("Diferente");
28.  getch();
29. }

Arreglos (Ejercicio 19-20)

Programa 19:

Ingreso de una matriz bidimensional, se realice la suma de sus columnas y los resultados, asignarlos a una matriz unidimensional.

1. #include<stdio.h>
2. #include<conio.h>
4. void main()
5. {
6.  clrscr();
7.  int md[3][3];
8.  int t[3]={0,0,0};
9.  int i,j,x=3,y=3;
10.  for(i=0;i<3;i++)
11.   {
12.    for(j=0;j<3;j++)
13.     {
14.      gotoxy(x,y);scanf("%d",&md[i][j]);
15.      x=x+3;
16.      t[j]=t[j]+md[i][j];
17.     }
18.     x=3;
19.     y=y+3;
20.   }
21.   y=12;
22.   x=3;
23.   for(j=0;j<3;j++)
24.    {
25.     gotoxy(x,y-1);printf("=");
26.     gotoxy(x,y);printf("%d\n",t[j]);
27.     x=x+3;
28.    }
29.   getch();
30. }

Programa 20:

Multiplicación de dos matrices cuadradas de 3x3.

1. #include<stdio.h>
2. #include<conio.h>
3.  
4. void main()
5. {
6.  clrscr();
7.  int m1[3][3],m2[3][3],c[3][3];
8.  int i,j,x=3,y=3,k;
9.  for(i=0;i<3;i++)
10.   {
11.    for(j=0;j<3;j++)
12.     {
13.      gotoxy(x,y);scanf("%d",&m1[i][j]);
14.      x=x+3;
15.     }
16.     x=3;
17.     y=y+3;
18.   }
19.    x=15;
20.    y=3;
21.   for(i=0;i<3;i++)
22.    {
23.    for(j=0;j<3;j++)
24.     {
25.      gotoxy(x,y);scanf("%d",&m2[i][j]);
26.      x=x+3;
27.     }
28.     x=15;
29.     y=y+3;
30.   }
31.    x=30;
32.    y=3;
33.    for(k=0;k<3;k++)
34.    {
35.    for(i=0;i<3;i++)
36.    { c[k][i]=0;
37.    for(j=0;j<3;j++)
38.     {
39.      c[k][i]=c[k][i]+m1[k][j]*m2[j][i];
40.     }
41.    gotoxy(x,y);printf("%d",c[k][i]);
42.     x=x+5;
43.    }
44.   x=30;
45.   y=y+3;
46.   }
47.   getch();
48. }

Arreglos (Ejercicio 17-18)

Ahora haremos unos programas de arreglos, algunos, haciendo aplicación a las matemáticas.
Programa 17:
Ingreso de dos matrices de 3 x 3 y realizar la suma, y presentar por pantalla la matriz resultante.
NOTA: Se especifica la dimensión de las matrices ya que como sabemos en matemática, la suma de matrices se puede hacer solamente, si ambas tienen el mismo numero de filas y columnas.

1. #include<stdio.h>
2. #include<conio.h>
3. void main()
4.  { clrscr();
5.    int a[3][3], b[3][3], c[3][3];
6.    int i,j,x=3,y=3;
7.    for(i=0;i<3;i++)
8.     {
9.        for(j=0;j<3;j++)
10.        {
11.          gotoxy(x,y);scanf("%d",&a[i][j]);
12.          x=x+3;  
13.        }
14.        y=y+3;
15.        x=3;
16.     }
17.     x=20;
18.     y=3;
19.    for(i=0;i<3;i++)
20.     {
21.        for(j=0;j<3;j++)
22.        {
23.          gotoxy(x,y);scanf("%d",&b[i][j]);
24.          x=x+3;
25.        }
26.        y=y+3;
27.        x=20;
28.     }
29.     x=37;
30.     y=3;
31.   for(i=0;i<3;i++)
32.     {
33.        for(j=0;j<3;j++)
34.        {
35.          c[i][j]= a[i][j]+ b[i][j];
36.          gotoxy(x,y);scanf("%d",&c[i][j]);
37.          x=x+3;
38.        }
39.        y=y+3;
40.        x=37;
41.     }
42. getch();
43. }

Como nos damos cuenta la suma se realiza con su respectivo elemento de indices iguales es decir c[0][0]=a[0][0]+b[0][0]; ,c[0][1]=a[0][1]+b[0][1];, y así sucesivamente en cada una de los ciclos de cada for() tienen los mismos valores.

Programa 18:
Ingreso de una matriz bidimensional, se realice la suma de sus filas y los resultados, asignarlos a una matriz unidimensional.

1. #include<stdio.h>
2. #include<conio.h>
4. void main()
5. {
6.  clrscr();
7.  int md[3][3];
8.  int t[3]={0,0,0};
9.  int i,j,x=3,y=3;
10.  for(i=0;i<3;i++)
11.   {
12.    for(j=0;j<3;j++)
13.     {
14.      gotoxy(x,y);scanf("%d",&md[i][j]);
15.      x=x+3;
16.      t[i]=t[i]+md[i][j];
17.     }
18.     x=3;
19.     y=y+3;
20.   }
21.   y=3;
22.   x=12;
23.   for(j=0;j<3;j++)
24.    {
25.     gotoxy(x,y);printf("= %d\n",t[j]);
26.     y=y+3;
27.    }
28.   getch();
29. }

Podemos apreciar un nuevo metodo de inicializacion en la 6ta linea de codigo del programa, donde cada cero corresponde a cada espacio del vector.

Arreglos Bidimensionales (Lectura y Escritura)

Para poder trabajar la lectura y la escritura de un arreglo bidimensional lo primordial es saber identificar las filas de las columnas. 

Las filas o renglones son las horizontales, y las columnas son las verticales en la matriz.

En la escritura y lectura es importante la presentación por pantalla, e importante que por pantalla se identifiquen las filas y las columnas, esto se puede lograr con una función especial de ubicación por pantalla.

Esta función es: gotoxy();, como su nombre lo dice go=ir; to=a; xy= coordenadas cartesianas ejes x,y. 

Como ejemplo el siguiente gráfico:

 Como apreciamos en el gráfico nos haremos idea de que los ejes x,y son nuestra pantalla, y que el gotoxy debe ir siempre antes de un scanf(); o un printf();, dentro del gotoxy(3,2); vemos dos números que son los que indican que ubicación en la pantalla tomara nuestro puntero para escribir o presentar los datos, en el ejemplo del gráfico tenemos, gotoxy(3,2);printf("hola");, que significa, que la palabra hola se presentará el la intersección del par ordenado (3,2), donde el primer numero representa al eje de las x es decir el 3, y el segundo numero representa al eje de las y en este caso el 2.

Esa función nos servirá de mucho en el uso de la lectura y escritura de matrices bidimensionales. ¿ Cómo? Pues de la siguiente manera.

Usando un for() anidado como en la inicialización, pero la diferencia es que en la inicializacion no es necesario presentar datos por pantalla, para la lectura el scanf(); y la escritura el printf();.

Primero haremos la lectura y escritura sin la función gotoxy();

#include<stdio.h>
#include<conio.h>
void main()
 { clrscr();
   int num[3][3];
   int i,j;
   for(i=0;i<3;i++)
    {
       for(j=0;j<3;j++) 
       {
         scanf("%d",&num[i][j]);
       }
    }
   for(i=0;i<3;i++)
    {
       for(j=0;j<3;j++) 
       {
         printf("%d",num[i][j]);
       }
    }
getch();
}

Apreciaremos que en ambos casos se ve una sola columna o fila. Debemos evitar eso haciendo lo siguiente con la función gotoxy();.
#include<stdio.h>
#include<conio.h> 
void main()
 { clrscr();
   int num[3][3];
   int i,j,x=3,y=3;
   for(i=0;i<3;i++)
    {
       for(j=0;j<3;j++) 
       {
         gotoxy(x,y);scanf("%d",&num[i][j]);
         x=x+3;  
       }
       y=y+3;
                x=3; 
    }
    x=20;
    y=3;
   for(i=0;i<3;i++)
    {
       for(j=0;j<3;j++) 
       {
         gotoxy(x,y);printf("%d",num[i][j]);
         x=x+3;
       }
       y=y+3;
                x=20;
    }
getch();
}
Al momento de correr el programa veremos en la presentación que con respecto al código anterior, se ve mejor presentada.

Arreglos Bidimensionales (Matriciales)

Estos arreglos a diferencia de los unidimensionales tienen dos dimensiones así como se menciona en su nombre, y como vimos un adelanto en ARREGLOS su definición de variables es la siguiente:

int numeros[3][3];

esto nos indica que es una matriz de tres por tres. 

Gráficamente y conceptualmente lo podemos ver así:

numeros: es el nombre de la matriz.


[3][3]: es el tamaño de filas y columnas, como vemos comienza desde cero y termina en dos en donde comprenden los tres espacios de memoria.


Los pares ordenados {(0.0);(0.1);(0.2);(1.0);(1.1);(1.2);(2.0);(2.1);(2.2)} son las posiciones de cada dato en la matriz.


Para inicializar cada uno de los elementos de la matriz en cero o cualquier otro número se lo hace como una matriz unidimensional:

numeros[0][0]=0;

numeros[0][1]=0;

   " ["]["]=0;

   " ["]["]=0;

numeros[n][n]=0;

Pero esa manera es la manera más tediosa, y como vimos en los arreglos unidimensionales podemos usar las estructuras repetitivas, como sabemos la estructura for() es la mas sencilla de usar, en este caso usaremos una estructura for() anidada, es decir otra estructura for() dentro de otra.

#include<stdio.h>
#include<conio.h>
void main()
{
 int num[3][3];
 int i,j;
  for(i=0;i<3;i++)
   {
     for(j=0;j<3;j++) 
     {
      num[i][j]=0;
     }
   }
}

Apreciamos que a diferencia de la inicialización de los arreglos vectoriales, aquí se necesitan dos variables, cada una para que me indique las filas y las columnas, i hace mención a las filas y j a las columnas