• Proyecto Calculadora

  

									
#ifndef CALCULADORA_H_INCLUDED
#define CALCULADORA_H_INCLUDED

#define DIVISON_POR_CERO -1

extern float suma(float a, float b);
extern float resta(float a, float b);
extern float multiplicacion(float a, float b);
extern float division(float a, float b);

#endif // CALCULADORA_H_INCLUDED
								

									
#include <stdlib.h>
#include "calculadora.h"

float suma(float a, float b){
    return a + b;
}

float resta(float a, float b){
    return a - b;
}

float multiplicacion(float a, float b){
    return a * b;
}

float division(float a, float b){
    if (b == 0){
        exit(DIVISON_POR_CERO);
    }
    return a / b;
}
								

									
#include <stdio.h>
#include <stdlib.h>
#include "calculadora.h"

int main(){
    int operacion, salir = 0;
    float operando_1, operando_2, resultado;

    while (!salir){
        printf("\nBienvenido a la calculadora\n");
        printf("Ingrese la operacion a realizar \n");
        printf("1: suma, 2: resta, 3: multiplicacion, 4: division, 5: salir) >>");
        scanf("%d", &operacion);
        fflush(stdin);

        if (operacion >= 1 && operacion <=4){
            printf("Ingrese dos operandos >>");
            scanf("%f %f", &operando_1, &operando_2);
            fflush(stdin);
        }

        switch(operacion){
        case 1: {
            resultado = suma(operando_1, operando_2);
            printf("Resultado de la suma: %f\n", resultado);
            break;
        }
        case 2:{
            resultado = resta(operando_1, operando_2);
            printf("Resultado de la resta: %f\n", resultado);
            break;
        }
        case 3:{
            resultado = multiplicacion(operando_1, operando_2);
            printf("Resultado de la multiplicacion: %f\n", resultado);
            break;
        }
        case 4:{
            resultado = division(operando_1, operando_2);
            printf("Resultado de la division: %f\n", resultado);
            break;
        }
        case 5:{
            salir = 1;
            printf("Gracias por utilizar los servicios de calculadora \n");
            break;
        }
        default:{
            printf("La operacion ingresada no es correcta \n");
        }
        }
    }
    return 0;
}
								

• Proyecto Variables y E/S

  

									
#ifndef ENCABEZADOS_H_INCLUDED
#define ENCABEZADOS_H_INCLUDED

// Prototipos de procemientos de prueba
extern void size_tipos_de_datos();
extern void rango_de_enteros();
extern void pruebas_con_boolean();
extern void pruebas_punteros();
extern void pruebas_string();
extern void pruebas_es();

#endif // ENCABEZADOS_H_INCLUDED
								

									
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

void size_tipos_de_datos(){
    printf("char: %d bytes\n", sizeof(char));
    printf("unsigned char: %d bytes\n\n", sizeof(unsigned char));

    printf("int: %d bytes\n", sizeof(int));
    printf("unsigned int: %d bytes\n", sizeof(unsigned int));
    printf("long int: %d bytes\n", sizeof(long int));
    printf("unsigned long int: %d bytes\n", sizeof(unsigned long int));
    printf("unsigned long long int: %d bytes\n\n", sizeof(unsigned long long int));

    printf("void *: %d bytes \n", sizeof(void *));
    printf("char *: %d bytes \n", sizeof(char *));
    printf("int *: %d bytes \n\n", sizeof(int *));

    printf("float: %d bytes\n", sizeof(float));
    printf("double: %d bytes\n\n", sizeof(double));
}

void rango_de_enteros(){
    int cant_bits = sizeof(int) * 8;

    int max_entero_positivo = pow(2, cant_bits - 1) - 1;
    int max_entero_negativo = -1 * pow(2, cant_bits - 1);
    unsigned int max_entero_no_signado = pow (2, cant_bits) - 1;

    printf("Maximo positivo de un SIGNED int: %d\n", max_entero_positivo);
    printf("Maximo negativo de un SIGNED int: %d\n", max_entero_negativo);
    printf("Maximo valor representable de un UNSIGNED int: %u\n\n", max_entero_no_signado);

    printf("Observar como se desbordan las variables... \n");
    printf("Maximo positivo de un SIGNED int incrementado en 1: %d\n", max_entero_positivo+1);
    printf("Maximo negativo de un SIGNED int decrementado en 1: %d\n", max_entero_negativo-1);
    printf("Maximo valor representable de un UNSIGNED int incrementado en 1: %u\n", max_entero_no_signado+1);
    printf("La respuesta al por que sucede esto podra obtenerla prontamente durante la materia... \n\n");
}
								

									
#include <stdio.h>
#include <stdlib.h>
#include "encabezados.h"

int main(){
    size_tipos_de_datos();
    rango_de_enteros();
    pruebas_con_boolean();
    pruebas_punteros();
    pruebas_string();
    pruebas_es();
    return 0;
}
								

• Proyecto Variables y E/S

  

									
#ifndef ENCABEZADOS_H_INCLUDED
#define ENCABEZADOS_H_INCLUDED

// Prototipos de procemientos de prueba
extern void size_tipos_de_datos();
extern void rango_de_enteros();
extern void pruebas_con_boolean();
extern void pruebas_punteros();
extern void pruebas_string();
extern void pruebas_es();

#endif // ENCABEZADOS_H_INCLUDED
								

									
#include <stdio.h>

void pruebas_con_boolean(){
    int a = (3 < 2);
    int b = !a;
    int c =  a || b;
    int d = 10;
    int es_par = (d % 2 == 0);

    printf("a vale: %d, b vale: %d y c vale: %d\n", a,b,c);

    if (1){
        printf("Entra aqui\n");
    }else{
        printf("Aqui no\n");
    }

    if (!es_par){
        printf("%d no es par, y es_par vale %d\n", d, es_par);
    }else{
        printf("%d es par, y es_par vale: %d\n", d, es_par);
    }
}
								

									
#include <stdio.h>
#include <stdlib.h>
#include "encabezados.h"

int main(){
    size_tipos_de_datos();
    rango_de_enteros();
    pruebas_con_boolean();
    pruebas_punteros();
    pruebas_string();
    pruebas_es();
    return 0;
}
								

• Proyecto Variables y E/S

  

									
#ifndef ENCABEZADOS_H_INCLUDED
#define ENCABEZADOS_H_INCLUDED

// Prototipos de procemientos de prueba
extern void size_tipos_de_datos();
extern void rango_de_enteros();
extern void pruebas_con_boolean();
extern void pruebas_punteros();
extern void pruebas_string();
extern void pruebas_es();

#endif // ENCABEZADOS_H_INCLUDED
								

									
#include <stdio.h>

// Este procedimiento arrojara warnings en compilacion.
// Esto se realiza asi para lograr observar el contenido de variables del tipo puntero sin inicializar.
void pruebas_punteros(){
    int * pi;
    char * pc;
    float * pf;
    int i = 10;
    float f = 7.5f;

    printf("El valor inicial del puntero pi es: %p\n", pi);
    printf("El valor inicial del puntero pc es: %p\n", pc);
    printf("El valor inicial del puntero pf es: %p\n", pf);

    printf("Se opera sobre el puntero pi y la variable f...\n");
    pi = &i;
    f = *pi;

    printf("El valor actual del puntero pi es: %p; en dicha direccion se halla el valor %d\n", pi, *pi);
    printf("El valor actual de la variable f es: %f\n", f);

    printf("Se opera con ++ sobre el puntero pi...\n");
    pi++;
    printf("El valor actual del puntero pi es: %p\n\n", pi);
}

// Este procedimiento arrojara warnings en compilacion.
// Esto se realiza asi para lograr observar el contenido de variables del tipo puntero sin inicializar.
void pruebas_string(){
    char cadena [] = "Hola";
    char * pcadena;

    printf("Cadena[0]: %c \n", cadena[0]);
    printf("Cadena[1]: %c \n", cadena[1]);
    printf("Cadena: %s \n", cadena);

    printf("El valor inicial del puntero pcadena es: %p\n", pcadena);

    printf("Se opera sobre el puntero pcadena...\n");
    pcadena = cadena;

    printf("El valor actual del puntero pcadena es: %p\n", pcadena);
    printf("El valor actual de cadena es: %p\n", cadena);

    printf("Primer char de pcadena: %c \n", *pcadena);
    printf("Segundo char de pcadena: %c \n", *(pcadena+1));
    printf("Todos los chars a partir de pcadena: %s \n\n", pcadena);
}
								

									
#include <stdio.h>
#include <stdlib.h>
#include "encabezados.h"

int main(){
    size_tipos_de_datos();
    rango_de_enteros();
    pruebas_con_boolean();
    pruebas_punteros();
    pruebas_string();
    pruebas_es();
    return 0;
}
								

• Proyecto Variables y E/S

  

									
#ifndef ENCABEZADOS_H_INCLUDED
#define ENCABEZADOS_H_INCLUDED

// Prototipos de procemientos de prueba
extern void size_tipos_de_datos();
extern void rango_de_enteros();
extern void pruebas_con_boolean();
extern void pruebas_punteros();
extern void pruebas_string();
extern void pruebas_es();

#endif // ENCABEZADOS_H_INCLUDED
								

									
#include <stdio.h>

void pruebas_es(){
    char buffer [20];
    char cadena [] = "Hola OC-UNS!";
    float f = 10.123456f;
    int d, m, a, cant_leido;

    printf("Imprimiendo el float formateado...\n");
    printf("%f:\n", f);
    printf("%.2f:\n", f);
    printf("%.5f:\n", f);
    printf("%10f:\n", f);
    printf("%-10f:\n", f);
    printf("%10.5f:\n", f);
    printf("%-10.5f:\n", f);
    printf("%e:\n", f);
    printf("%.2e:\n\n", f);

    printf("Imprimiendo la cadena \"%s\" formateada...\n", cadena);
    printf("%s:\n", cadena);
    printf("%10s:\n", cadena);
    printf("%.10s:\n", cadena);
    printf("%.*s:\n", 10, cadena);
    printf("%-10s:\n", cadena);
    printf("%.15s:\n", cadena);
    printf("%-15s:\n", cadena);
    printf("%15s:\n", cadena);
    printf("%15.10s:\n", cadena);
    printf("%-15.10s:\n\n", cadena);

    printf("Ingrese una cadena sin separadores >>");
    scanf("%15s", buffer);
    fflush(stdin);
    printf("La cadena leida es %s\n", buffer);

    printf("Ingrese otra cadena con sepadores>>");
    scanf("%[^\n]", buffer);
    fflush(stdin);
    printf("La cadena leida es %s\n", buffer);

    printf("Ingrese una fecha separadas por / >>");
    cant_leido = scanf("%d/%d/%d", &d, &m, &a);
    if (cant_leido == 3){
        printf("La fecha es: %d/%d/%d\n\n", d, m, a);
    }else{
        printf("La fecha ingresada es invalida\n\n");
    }
}
								

									
#include <stdio.h>
#include <stdlib.h>
#include "encabezados.h"

int main(){
    size_tipos_de_datos();
    rango_de_enteros();
    pruebas_con_boolean();
    pruebas_punteros();
    pruebas_string();
    pruebas_es();
    return 0;
}