Buscador Elinv.

Búsqueda personalizada

lunes, 11 de julio de 2011

C++ - Arreglos de Enteros, crear, llenar, mostrar suma, hallar un elemento, retorno de función con múltiples valores por Elinv.

/*
*
Código presentado por Elinv.

* http://www.bragadomas.com/forodeprogramacion/index.php
*
http://www.bragadomas.com
*
http://www.bragadomas.com.ar
*
http://luispedromendez.blogspot.com/
*
http://elinv-elinv.blogspot.com/?expref=next-blog
*/


/*
 *CodeBlocks 10.05
 *C
 *Explicado por Elinv.
 *Crear un array o matriz, dimensionándola
 *Llenarla, mostrarla, mostrar la suma de sus elementos
 *Saber si un determinado elemento está contenido en la matriz
 *o el array.
 *función con retorno de múltiples valores
 */
#include <cstdlib>
#include <iostream>
#include<stdio.h>
using namespace std;
//Prototipo de funciones
void llenar_matriz(int array[],int cant_elementos);
void mostrar_matriz(int array[],int cant_elementos);
int sumar_matriz(int array[],int cant_elementos);
int * hallar_elemento(int array[],int cant_elementos,int elemento_a_hallar);
//Procedimiento principal
int main()
{
    //inicializamos el array a un número determinado máximo de elementos.
    int array[100];
    //Declaramos otros variables que necesitamos
    //para la cantidad de elementos del array
    int cant_elementos;
    //Aquí solicitamos que dimensione el array a n elementos
    do
    {
        printf("Arreglos su funcionamiento: \n");
        printf("--------------------------- \n");
        printf("Funci¢n con retorno de m£ltiples valores \n");
        printf("--------------------------- \n\n");
        printf("Ingrese la dimensi¢n del array a llenar: \t");
        scanf("%d",&cant_elementos);
    }
    //Observen que manera elegante de validar la cantidad de elementos
    while(cant_elementos<0 || cant_elementos>100);
    //Con esta función llenamos el array o matriz hasta tal cantidad de elementos
    llenar_matriz(array,cant_elementos);
    //Aquí mostramos la matriz
    mostrar_matriz(array,cant_elementos);
    //Declaramos variable que obtendrá la suma de los elementos contenidos.
    int suma_total_matriz;
    //Llamamos a la función de suma y devolvemos a la variable anterior el total obtenido
    suma_total_matriz=sumar_matriz(array,cant_elementos);
    //Mostramos el resultado
    printf("\nLa suma es: \t%d\n",suma_total_matriz);
    //Declaramos variable para el elemento a buscar
    int elemento_a_buscar;
    //Solicitamos por pantalla un elemento determinado a buscar en la matriz
    printf("\nIngrese elemento de la matriz a buscar : \t");
    //Lo aceptamos por teclado
    scanf("%d",&elemento_a_buscar);
    //Si la función nos devuelve 1
    int *respuesta;
    //Capturamos en la variable respuesta el array con el contenido
    respuesta = hallar_elemento(array,cant_elementos,elemento_a_buscar);
    if(respuesta[0] == 1)
    {
        printf("\nEl elemento %d se encuentra contenido en el array!\n", elemento_a_buscar);
        printf("\nEn el ¢rden \t\t\t\t\t%d\n\n", respuesta[1]+1);
    }
    else
    {
        printf("\nEl elemento %d no se encuentra", elemento_a_buscar);
    }
    //Pausamos el sistema para poder ver el resultado.
    system("PAUSE");
    //Salimos.
    return EXIT_SUCCESS;
}
//Función para llenar la matriz
void llenar_matriz(int array[],int cant_elementos)
{
    //Declaramos variables.
    int x;
    //Recorremos el array hasta la cantidad de elementos
    for (x=0; x<cant_elementos; x++)
    {
        //Solicitamos que se ingrese un valor
        printf("Ingrese un valor para la matriz[%d]:\t\t",x);
        //Lo tomamos por teclado directamente al array
        scanf("%d", &array[x]);
          }
      }
//Función para mostrar la matriz
      void mostrar_matriz(int array[],int cant_elementos)
{
    //Variable para el bucle
    int x;
    //Recorremos el array hasta la cantidad de elementos.
    for (x=0; x<cant_elementos; x++)
    {
        //Mostramos los elementos y el valor contenido
        printf("Valor matriz: elemento[%d] = \t\t\t%d\n",x,array[x]);
    }
}
//Función para sumar los elementos de la matriz
int sumar_matriz(int array[],int cant_elementos)
{
    //Declaramos variables.
    int suma=0;
    int x;
    //Recorremos el array y vamos sumando.
    for(x=0; x<cant_elementos; x++)
    {
        //Sumamos elementos del array
        suma=suma+array[x];
    }
    //retorno de la función.
    return suma;
}
//Función para hallar un elemento en el array
int * hallar_elemento(int array[],int cant_elementos,int elemento_a_hallar)
{
    //Variables
    int i=0;
    int *respuesta;
    //Creamos el arreglo en memoria
    respuesta = (int*) malloc ( sizeof(int) * 2);
    //Lo inicializamos
    respuesta[0]=0;
    respuesta[1]=0;
    //Ciclo while mientras i sea menor a la cantidad de elementos y
    //hallar elemento igual a cero
    while(i<cant_elementos && respuesta[0]==0)
    {
        //Si el elemento que recibe la función es igual al elemento del array
        if(elemento_a_hallar==array[i])
        {
            //cambiamos el valor de la variable y salimos del ciclo.
            //Aquí decimos que lo hemos hallado
            respuesta[0]=1;
            //Aquí en que lugar del array o matriz
            respuesta[1]=i;
        }
        else
        {
            //Caso contrario aumentamos el valor de i, que es el siguiente
            //elemento del array
            i++;
        }
    }
    //retornamos el valor de la variable respuesta
    //Pero retornamos múltiples valores contenidos como respuesta.
    return respuesta;
}