Bienvenidos A nuestro foro, espero que os guste


    tema 3 arnaudis (sin resumir

    Comparte
    avatar
    Thane
    Admin

    Mensajes : 20
    Fecha de inscripción : 27/11/2009

    tema 3 arnaudis (sin resumir

    Mensaje  Thane el Vie Mar 05, 2010 2:24 pm

    (Teoría segunda evaluación)
    F. DEFINICION DE NUEVOS TIPOS
    Aveces conviene renombrar los tipos de datos que existen de manera que faciliten la lectura y escritura del código fuente. Esto se hace mediante la sentencia Typedef, que se usa para renombrar tipos de datos.
    Typedef int entero;  renombra int por entero.
    G. CONSTANTES
    Una constante en “C” es un valor fijo que no puede modificarse a lo largo de la ejecución del programa. Una vez compilado no puede alterarse durante la ejecución.

    2.3 OPERADORES Y EXPRESIONES
    Una expresión es una combinación de operadores y operandos en “C” que producen un valor o generan un efecto secundario. Las variables y constantes se consideran las expresiones más simples puesto que proporcionan un valor directamente.
    Ejemplo:
    3(expresión/operando)+(operador)a+8
    A. OPERADORES ARITMETICOS
    Se utilizan para realizar operaciones normales.
    o Binarios (+ - * /)
    o Unarios (–  signo de la fracción, que indica negativo)

    B. OPERADORES RELACIONALES
    Se utilizan para determinar las relaciones entre valores. El resultado de toda operación relacional es siempre verdadero o falso.
    En “C” el verdadero es un 1 y el falso es un 0 y los operadores son (>, >=, <, <=, !=  esto representa distinto)
    C. OPERADORES LOGICOS
    Los operadores lógicos se utilizan para representar las conexiones lógicas (y, o) y la negación. Mediante estos operadores se pueden crear expresiones relacionales complejas a partir de expresiones más simples.
    o Y  conjunción: Se representa en “C” mediante el símbolo “&&”.
    o O  disyunción: Se representa en “C” mediante el símbolo “||”
    o La negación se representa con !
    *El resultado de las operaciones lógicas es verdadero o falso 0 o 1.
    Ejemplo:
    X = 5
    Y = 2
    Relación =(( x != y)) (x<y)
    1 0
    Relación = 1
    Ejemplo 2:
    Relación = ((x!=y) && ((x>y))
    1 1
    Relación = 1
    Ejemplo 3:
    Relación = !(x= = y)
    = ! 0
    Relación = 1

    D. OPERADORES DE INCREMENTO Y DECREMENTO
    Son una de las operaciones más comunes dentro de la programación. En “C” se puede poner el incremento mediante “++”, y el decremento mediante “—“, a la vez que se admiten como prefijos y sufijos.
     X++  sufijo  esto = x + 1
    Post incremento o post decremento
     X--  sufijo  esto = x – 1

     ++X  prefijo  esto = 1 + x
    Pre incremento o pre decremento
     --X  prefijo  esto = 1 - x

    Ejemplo:
    #include <stdio.h>
    Main ()
    {
    Int x, y;
    x=y=9;
    printf(“el valor de x es %d”, x++);  9; x= 10  pos incremento, 1º muestra y luego aumenta
    prinft(“el valor de y es %d”, ++y);  y=10; 10  pre incremento, 1º aumenta y luego muestra
    }

    E. OPERADORES DE ASIGNACIÓN
    Se utiliza para asignar la expresión de la derecha de la variable. El símbolo es el “=”. Se puede aplicar a varias variables.
    Por ejemplo  x = y = z = 2  las tres variables pasan a valer 2.
    Las asignaciones se evalúan de derecha a izquierda y hay una determinada forma de representar determinadas asignaciones, que son:
    o X + = Y;  x = x + y;
    o X - = Y;  x = x – y;
    o X * = Y;  x = x * y;
    o X / = Y;  x = x / y;
    o X % = Y;  x = x % y
    A esto se le llama sobrecarga de la operación a realizar  por ejemplo, sobrecarga de multiplicación.






    Traducir este otro:

    F. OPERADORES Y EXPRESIONES
    Ejemplo:
    #include <stdio.h>
    Main()
    {
    Char x= “A”; /* en binario x = 01000001 */
    Char y =”Z”; /* en binario y = 01111010 */
    Char z;
    Int i = 14550; /* en binario i= 00000000000000000011100011010110
    z = x&y; /* el resultado es z = 01000000 */
    printf (“z = %c \ n”, z);  /* imprime z= @;
    z = x/y; /* z= 01111011 */
    printf (“z = %c\n” z)  /* imprime z = { */
    z = x*y; /* z=00111011 */
    printf (“z=%c\n”, z)  /* imprime x = ; */
    z = x >>1; /* z = 00100000 */
    printf (“z = %c\n”, z)  /* imprime z = no hay símbolo definido */
    z= *i; /* z = 1111111111111111 11 */
    printf )”z=%d\n”, z); /* imprime z = -14551 */

    G. OPERADOR CONDICIONAL
    Es un operador ternario con la siguiente sintaxis:
    - Expresión 1 ? expresión 2: expresión 3
    Este operador evalúa la expresión 2 o la expresión 3 dependiendo de la evaluación de la expresión 1.
    En otras palabras, evalúa la expresión 1, si es verdadera ejecuta la expresión 2 y en caso contrario la expresión 3.
    Ejemplo:
    Nota = (teoría > = 5) ¿ teoría + practica : 0;
    Si teoría es >=5, nota = teoría + practica. Si no, nota = 0
    Todo esto equivale a una sentencia de control de flujo.
    H. SENTENCIAS DE CONTROL
    Una sentencia es una instrucción completa que el ordenador es capaz de entender. En c hay 5 tipos:
    o Declaración: Se utilizan para establecer nombres y tipos de las variables
     Ej: int valor;
    char carácter;
    o Asignación: Se utilizan para asignar valor a las variables utilizando un operador de asignación
     Ej: valor = 5;
    char carácter;
    o Función: Este tipo de sentencias son llamadas a una función que realiza alguna tarea.
     Ej: printf (“es un ejemplo\n”);
    o Control: Estas sentencias permiten controlar el flujo de ejercicios del programa.
     Ej: While (valor>1)
    valor ++;
    o Nulas: No realizan ninguna operación.

    I. OPERADORES DE MANEJO DE BITS
    El “C”, como vimos en el tema 1, puede manipular a bajo nivel de memoria y para ello necesita operadores a nivel de bits que permitan manipular las variables a nivel de bit.
    Estos son aplicables a todas las variables int, short, long y char y no a float y doublé.
    Los operadores son:
    o &  Y lógico (AND)
    o |  O lógico (OR)
    o ^  O exclusivo (XOR)
    o <<  desplazamiento a la izquierda. Se rellenan 0 a la derecha
    o >>  desplazamiento a la derecha. Se rellenan 0 a la izquierda
    o ~  complemento a 1
    Segunda evaluación:
    Ejercicios de implementación en C:
    1-
    Entero a,p  int a,p;
    Leer a  scanf (“%d”, &a);
    Si (a>7) entonces  if (a>7)
    Escribir “notable”  printf (“notable\n”);
    Fin si }

    2-
    Entero a,b,c;  int a,b,c;
    C=0;  c = 0;
    Leer b;  scanf (“%d”, &b);
    Mientras (c<3) hacer  while (c < 3)
    {
    Escribir b*b  printf (“%d”, b*b); printf (“\n”)
    B=b*b  b*=b
    C=c+1  c++
    }
    Fin mientras
    A=(c+b)mod2  a=(c+b)%2;
    Escribir a  printf (“%d”, a);



    Tema 3: Funciones en C
    3.1. INTRODUCCION
    En el tema 2 hemos visto que una función es un fragmento de código que realiza una tarea bien definida. Por ejemplo, la función “Printf” imprime por la salida estándar el contenido que se le ordene. Esta es una función predefinida y son denominadas “funciones de biblioteca”.
    Cada programador puede realizar las suyas propias, de acuerdo a sus necesidades, a estas funciones se las llaman funciones de usuario.
    La utilización de funciones permite dividir un programa extenso en pequeños segmentos de código que realizan tareas concretas, tareas que se van a ejecutar dentro de un programa alomejor alguna vez. A esto se le llama reutilización de funciones.
    La filosofía del “C” se basa en el uso de funciones. Por eso el programa contiene al menos una función, la función “Main”, y solo puede contener una función “Main”.
    Cuando se ejecuta el programa, es la primera y única función a la que se llama, a su vez, la función “Main” puede llamar a otras funciones.
    En “C” no se permite la anidación de funciones, es decir, dentro de una función no se permite definir otra, pero si invocarla.
    Las funciones pueden invocarse desde cualquier punto. Cuando llamamos a una función, le pasamos el control del programa y comienzan a ejecutarse las instrucciones de esa función. Cuando se termina la función el control del programa pasa a la siguiente instrucción desde la que se llamo a la función.
    Cuando invocamos a una función se le puede pasar argumentos, llamados también parámetros.
    De una función se devuelve un valor mediante la palabra reservada “Return”. La estructura de una función es:
    Tipo.de.retorno nombre_funcion (lista_parametros)
    {
    Instrucciones;
    Return expresión
    }
    “Tipo de retorno” tiene que ser del mismo tipo que expresión.

    Definiciones:
    Tipo de retorno:
    Es el tipo de valor devuelto por la función, por ejemplo enteros o ristras. En caso de que no se devuelva nada el tipo es “VOID”.
    Nombre_Funcion:
    Es el nombre que queramos darle a la función (nooooo ¿en serio? xD).
    Lista_Parámetros:
    Es la lista de declaración de los parámetros que son pasados a la función.
    Instrucciones:
    Son las órdenes o sentencias que va a ejecutar la función.
    Return Expresión:
    Mediante la sentencia “Return” se devuelve el valor de la función, que este caso es expresión.
    Ejemplo:
    Int kk ()
    {
    Printf (“hola|n”);
    Return 0
    }

    A. Diferencia ENTRE FUNCIONES Y PROCEDIMIENTOS
    Básicamente son lo mismo, pero la diferencia principal está en la devolución. Un procedimiento no devuelve, ni tiene porque devolver, mientras que una función siempre devuelve, aunque sea un void (si una función no lleva return devuelve un void de forma implícita).
    Consideraciones a tener en cuenta:
    1- En “C” solo hay funciones, no hay procedimientos
    2- En “C” se pueden simular procedimientos, para ello:

    Void ________
    {

    Return
    }
    Ejemplo:
    #include <stdio.h>
    #include <conio.h>
    Float area (float base, float altura);
    Main ()
    {
    float base = 3.6;
    Float altura = 2.2;
    Printf ("el área del triangulo es %f\n", área(base, altura));
    Getch ();
    Return 0;
    }
    Float area (float base, float altura)
    {
    Return (base*altura)/2;
    }
    En el ejemplo hay dos funciones. Al iniciar la ejecución el control pasa a la función main que cuando ejecuta la instrucción printf llamará a la función “area” que ha sido declarada al principio del programa. Ojo con los tipos de datos. Ver que los parámetros pasados coincidan en tipo y posición al igual que los devueltos.
    Explicación del ejercicio:
    1- Le decimos que incluya el ejercicio en el archivo stdio.h.
    2- Declara como reales la altura y la base.
    3- Inicia la función main que controla los valores.
    4- Da los valores a altura, a base y muestra por pantalla la frase “el área del triangulo es”, con salto de línea.
    5- El getch hace que la ventana no desaparezca cuando ejecutamos el programa.
    6- Ese return devuelve un 0.
    7- Hacemos que se invoque la base y la altura y retorne la multiplicación de la misma entre 2. Dando así como resultado el área del triangulo.
    8- Al final quedaría el área del triangulo es “el resultado de esa operación”.
    9- Dicha operación se pone en el printf. En la parte área (base, altura).

    3.2. DECLARACION DE FUNCIONES
    Antes de utilizar una función debemos declararla. La declaración de una función se conoce también como prototipo de la función.
    En el prototipo de la función se tienen que especificar los parámetros de la función, así como el tipo de datos que devuelve.
    La sintaxis general es:
    tipo_retorno nombre_funcion (lista_parametros);
    Ejemplos:
    1. int cubo (int a);
    2. char valor (int kk);
    Destacar que el nombre de los parámetros que se pasan es opcional, pero mejora la lectura.
    Los prototipos de las funciones son utilizados por el compilador para verificar que se accede a la función de la manera adecuada respecto al número y tipo de parámetros y al tipo de valor que retornan.
    Las funciones de biblioteca se declaran en los llamaros ficheros de cabecera o “.h”. (header  cabecera  .h).
    Cuando deseamos utilizar alguna de las opciones de la biblioteca, debemos especificar el fichero “.h” en el que se encuentra declarada la función.

    3.3 DEFINICIÓN DE FUNCIONES
    Después de definir una función hay que implementarla. A esto se le conoce como definición de una función.
    En la definición es en donde se especifican las instrucciones que forman parte de la misma, y que se utilizan para llevar a cabo la tarea específica de la función.
    La definición de una función consta de dos partes, encabezado y cuerpo de la función.
    En el encabezado, al igual que en el prototipo, se tienen que especificar los parámetros de la función si es que se utilizan, al igual que el tipo de datos que devuelve, mientras que en el cuerpo se escriben las instrucciones necesarias para realizar la tarea.
    Si en la declaración o definición de una función no se especifica el tipo de devolución el compilador asume/entiende que se devuelve un entero.
    En caso de que una función no utilice parámetros, se pueden dejar los paréntesis vacíos o incluir void, que indica que la función no lleva parámetros. Después del encabezado viene el cuerpo, las instrucciones que están dentro del cuerpo y las delimitadas por { }.
    Ejemplo:
    1. int cubo (int a)
    {
    a = 4
    a = a x a x a;
    return a;
    }

    3.4 DEVOLUCIÓN DE VALORES
    Una función en “C” solo puede devolver un valor, para ello utiliza la palabra clave return.
    La sintaxis es “return expresión”, donde return puede ser cualquier tipo de datos salvo un vector y una función. El valor de la expresión debe coincidir con el del tipo de la función.
    Si no se puede devolver un vector. ¿Cómo devolvemos múltiples valores?
    Se devuelven mediante el uso de punteros o estructuras.
    Dentro de una función se puede dar la ubicación de varios return. Si por el contrario no hay ningún return, la ejecución de la función se hará hasta llegar al final y encontrarse el }.
    Hay que tener cuidado con las funciones que no devuelven nada, es decir, que devuelven el tipo “void”.

    3.5 ACCESO A UNA FUNCION
    Para que una función haga su tarea o ejecute sus instrucciones debe ser llamada o invocada. Cuando se llama a una función, se le pasa el control del programa y solo lo devuelve cuando se encuentre un return, o en su defecto lleguemos al “}” del final.
    A las funciones se les suele llamar desde la “Main” por lo que implica que se puede llamar a las funciones desde cualquier otra función.
    Para acceder a una función, debemos hacerlo mediante su nombre seguido de la lista de argumentos de dicha función entre paréntesis.
    Si no hay argumentos, se utilizan los paréntesis vacios (). Cualquier expresión puede tener una llamada a una función.
    Ejemplo:
    1. A = cubo (2);
    2. Z = c + cubo (3) + a;
    A los argumentos que utilizamos en la llamada se denominan “argumentos reales”. Deben coincidir el número y tipo con los argumentos formales o parámetros de la función, que son los que están en el prototipo de la función. Los argumentos formales son los que se utilizan en la definición y/o declaración de la función.
    Ejercicio de muestra de funciones:

    Pseudocódigo para pedir 2 valores y sumarlos. Utiliza funciones.
    1º HAGO LA FUNCION QUE PIDE
    funcion entero sumar (entero v1, entero v2)
    inicio
    devolver v1+v2
    2º HAGO LA PARTE PRINCIPAL DEL EJERCICIO
    inicio suma
    entero a, b, pp
    leer a  sobrescribirá a v1
    leer b  sobrescribirá a v2
    pp = sumar (a, b)  pp será c
    escribir pp  escribirá c
    fin suma

    MUCHO OJO, PP NO QUIERE DECIR PP = C, QUIERE DECIR QUE SUSTITUYE AL VALOR C DE LA FUNCION, DIGAMOS QUE LO SOBREESCRIBE POR LO QUE VALDRA LO MISMO.
    2º ejercicio para entender funciones
    1. Realizar un programa en pseudocódigo para pedir 3 números y multiplicarlos. Utilizar funciones
    inicio multiplicar
    entero a, b, c, pp
    leer a
    leer b
    leer c
    pp = multiplicar (a, b, c)
    mostrar (pp)
    fin multiplicar
    funcion entero multiplicar (entero v1, entero v2, entero v3)
    entero pp
    pp = v1*v2*v3
    devolver pp
    fin funcion multiplicar
    funcion void mostrar (entero pp)
    escribir pp
    fin funcion mostrar
    2. Realizar un programa que pida un nº que equivale a grados Celsius, llame a una función pasándole dicho valor y devuelva el equivalente en grados kelvin y grados Fahrenheit. Haz otra función que será donde se representen por pantalla los resultados.

    Usa variables locales.

    ºC = ((ºF - 32)*5)/9
    ºF = ((ºC * 9)/5)+32
    ºK = 273 + ºC
    Hacerlo en pseudocódigo y en lenguaje “C”.
    Function real Fahrenheit (entero C)
    Real kk
    Kk = C x 9
    Kk = kk / 5
    Kk = kk + 32
    Devolver kk
    Fin función Fahrenheit
    Función entero Kelvin (entero c)
    Entero kk
    Kk = 273 + c
    Devolver kk
    Fin función Fahrenheit
    Función void mostrar (entero c, real f, entero kk)
    Escribir c+ “grados Celsius equivalen a “f+” grados Fahrenheit y “+k+” grados kelvin”
    Fin función kelvin


    Inicio ej1
    Entero Celsius, kelv
    Real faren
    Escribir “introduzca una temperatura en grados Celsius:”
    Leer Celsius
    Faren = Fahrenheit (Celsius)
    Kelv = Kelvin (Celsius)
    Mostrar (Celsius, faren, kelv)
    Fin ej1
    Deberes:
    • Realizar un algoritmo en pseudocódigo que pida 3 valores y me diga cuál es el más pequeño. Hay que comprobar que pueden ser iguales y hay que utilizar funciones, tanto para saber cuál es el pequeño como para mostrar.
    Vale pero no lo hemos dao -.-u.
    Inicio pequeño
    Ristra pp
    Pp = pequeño (pp)
    mostrar (pp)
    Fin pequeño

    Inicio función ristra pequeño (ristra pp)
    Entero v1, v2, v3
    Leer v1
    Leer v2
    Leer v3
    Si ((v1<v2) y (v1 < v3)) entonces
    pp = “el primero es el menor”
    sino
    Si ((v2 < v1) y (v2 < v3)) entonces
    pp = “el segundo es el menor”
    sino
    Si ((v3 < v1) y (v3 < v2)) entonces
    pp = “el tercero es el menor”
    sino
    Si ((v1 = v2) y (v1 = v3)) entonces
    pp = “los tres son iguales”
    Fin si
    Fin si
    Fin si
    Fin si
    Devolver pp
    Fin función pequeño
    Inicio Función void mostrar (ristra pequeño)
    Escribir pequeño
    Fin función mostrar

    Este si vale según lo que hemos dao -.-u
    Inicio ej8
    Entero a, b, c, pp
    Leer a
    Leer b
    Leer c
    Pp = pequeño (a, b, c)
    Mostrar pp
    Fin ej8
    Inicio función entero pequeño (entero v1, entero v2, entero v3)
    Si ((v1=v2) y (v1=v3)) entonces
    Devolver v1
    Sino
    Si ((v1<v2) y (v1<v2)) entonces
    Devolver v1
    Sino
    Si ((v2<v1) y (v2<v3)) entonces
    Devolver v2
    Sino
    Devolver z
    Fin si
    Fin si
    Fin si
    Fin función pequeño
    Inicio función void mostrar (entero menor)
    Escribir menor
    Fin función mostrar

    3.6 AMBITO Y CLASES DE ALMACENAMIENTO
    Las variables se clasifican según su tipo de datos, pero. también pueden clasificarse según su ámbito, es decir, las partes en las que una variable es reconocida.
    Según su aumento, las variables pueden ser locales o globales. Por otra parte, existen modificadores de tipo o clase de almacenamiento que permiten modificar el ámbito y la permanencia de una variable dentro del programa.
    Existen 4 tipos de modificadores:
    - Auto
    - Static
    - Extern
    - Register
    3.7 VARIABLES LOCALES
    Cuando declaramos variables dentro del main, estas están asociadas al main, es decir, son variables locales y solo se puede acceder a ellas dentro de la función main.
    Cualquier variable declarada dentro de una función es local a esa función e invocada solo desde esa función. Si ámbito es esa función.
    Hay modificadores para modificar dicha situación.



    Ej:
    #include <stdio.h>
    Int kk ();
    Void main ()
    {
    Int a, b;
    a=2
    Printf (“a vale %d\n”, a);
    b=kk ();
    }
    Int kk ()
    {
    Int a=1;
    Printf (“a es %d\n”, a);
    Return a;
    }

    3.8 VARIABLES GLOBALES
    Una variable global es aquella que tiene como ámbito todo el programa. Las variables globales proporcionan un mecanismo de intercambio de información entre funciones sin necesidad de utilizar argumentos.







    Ej:
    #include <stdio.h>
    Void kk()
    Int global;
    Main()
    {
    Global=7;  al retornar de la función kk, global valdrá el valor que salió de la función, o sea, 5
    Kk ();
    }
    Void kk ()  al entrar en la función, global vale 7
    {
    Global=5;
    }
    El uso de variables globales como mecanismo para transferir información puede ser útil pero puede conllevar problemas de interpretación.
    Una variable que se declare global puede provocar problemas con otra variable con el mismo nombre local a una función concreta.
    La definición de una variable global se hace fuera de cualquier función.
    Para que una función pueda utilizar una variable global no tiene más que usarla mediante su nombre.
    Ahora bien, puede darse la situación de que una función vaya a tener el mismo nombre que una variable global. En ese caso, si la variable global se define antes que la función no hay problemas.
    Pero ante cualquier duda, se soluciona mediante la utilización de la palabra reservada “extern”.
    Al utilizar extern, le estamos diciendo al compilador que reserve un espacio de memoria para la variable en cuestión, que va a ser global.
    Recordar que toda variable global en su declaración debe ser inicializada.
    Puede ocurrir que con una aplicación compuesta por varios ficheros, se desee utilizar una variable global declarada en otro fichero. Para ello, en el fichero donde vamos a utilizarla tendremos que incluir el fichero en cuestión mediante #include.

    3.9 VARIABLES ESTATICAS
    Vienen reservadas por la palabra reservada “Static”. Pueden ser tanto locales como globales.
    Una variable estática local es una variable asociada solo a la función en la que se declara pero con la salvedad de que su existencia es permanente.
    Es decir, el contenido de la variable no se borrara hasta que no la termine el programa. Ahora bien, solo se podrá acceder a ella si nos encontramos en la función donde está declarada.
    Por otra parte, el calificador static en variables globales hace que estas solo sean accesibles desde el fichero en que se definieron y no desde otro fichero fuente.
    Ej.
    Static int tiempo;
    Static int valor
    Int main()
    {
    …………
    }
    Void function ()
    {
    ………..
    }
    El identificador “static” también se utiliza para las funciones. Podemos tener la circunstancia de tener una función en un fichero que solo queremos que se utilice dentro de ese fichero. Pues en la declaración de la función lo primero que debemos poner es “static”.


    3.10 VARIABLES DE REGISTRO
    Cuando almacenamos una variable como variable de registro, le estamos diciendo al compilador que queremos que la variable se almacene en un lugar de rápido acceso.
    Para hacer su declaración, debemos poner al principio la palabra reservada “register”.
    Ej.
    Register int kk;
    Register char a;
    El uso de tipo “register” no nos asegura que la variable vaya a ser almacenada en un registro. Esto es debido a las limitaciones de hardware que existen.
    3.11 PASO DE ARGUMENTOS Y PUNTEROS
    En “C” todos los argumentos se pasan por valor. Lo que realmente se pasa es una copia del valor del argumento y no está en si misma.
    Cualquier modificación que se realice tendrá efectos solo dentro de la función.
    Ej.
    #include <stdio.h>
    Main ()  void modificar (int variable);
    {
    Int i = 1;
    Printf(“\n i= %d antes de llamar a la function”, i);
    Modificar (i);
    Printf(“\n variable = %d después de llamar a la función”, i);
    }
    Void modificar (int variable)
    {
    Printf (“\n variable = %d dentro de modificar”, variable);
    Variable = 9;
    Printf(“\n variable=%d dentro de modificar”, variable);
    }
    Dentro de la función, el valor primero es 1 y luego pasa a ser 9 pero una vez sale el main nuevamente el valor de i será 1 puesto que por el tipo de paso de valor no se modifica el valor original de la variable.
    Hay ocasiones en las que queremos que dichos valores se modifiquen. Para lograrlo hay que utilizar el paso de argumentos por referencia. Aquí no se pasa una copia, sino el argumento en sí.
    Este tipo de paso, realmente lo que pasamos son direcciones de memoria, realmente la de los argumentos.
    Estamos pasando punteros a los argumentos.
    Ej.
    #include <stdio.h>
    Void modificar (int * variable);
    Main()
    {
    int i = 1
    printf (“\n i vale %d”, i);
    modificar (& i); modificacion
    printf(“\n I vale %d”, i);
    }
    Void modificar (int * variable)
    {
    Printf(“\n variable vale %d”, * variable);
    *variable=9 modificación
    Printf (“\n variable vale %d”, *variable);
    Mediante este ejemplo, el valor de; si va a cambiar al ser invocada la función modificar. Para ello se han utilizado punteros.
    Para pasar el puntero hay que pasar la dirección de memoria y ello se hace mediante el &. Luego para trabajar con el contenido hay que usar el *.


    3.12 RECURSIVIDAD
    En “C” las funciones pueden ser recursivas, es decir, pueden llamarse a sí mismas directa o indirectamente.
    La recursividad directa es aquella donde una función se llama a si misma desde el propio cuerpo de la función. La indirecta implica a mas de una función.
    Una función recursiva tiene que tener una condición de finalización porque podría estar ejecutándose infinitamente.
    El ejemplo típico es el cálculo del factorial.
    n!= n • (n-1) • (n-2)…..3 • 2 • 1
    lo que hay que hacer es multiplicar el nº actual por el resultado de la función pasándole el nº actual menos uno, todo esto siempre que el nº actual no sea 1, caso en el que devolvemos un 1.
    Una solución sin recursividad podría ser:
    #include <stdio.h>
    Int factorial (int n);
    Main ()
    {
    Int valor =4;
    Int resultado;
    Resultado = factorial (valor);
    Printf(“El factorial de %d es %d\n”, valor, resultado);
    Return 0;
    }
    Int factorial (int n)
    {
    Int i;
    Int devuelve = 1
    For (i=1; i<=numero; i++)
    {
    Devuelve = devuelve * i;
    }
    Return devuelve;
    }
    Con recursividad simplemente cambiaríamos la function factorial por:
    Int factorial (int n);
    {
    If (numero == 1)
    Return 1;
    Else
    Return (numero * factorial (numero -1));
    }
    Ej. Como ejercicio realizar una traza correspondiente para calcular el factorial de 4.

    3.13 FUNCIONES DE BIBLIOTECA
    Las funciones de biblioteca son aquellas proporcionadas por el “C”. para verlas simplemente hay que llamarlas y ha de incluirse previamente el fichero de cabeceras que lo contiene.
    Ficheros .h con los prototipos de las funciones
    Las funciones del mismo grupo se engloban o agrupan dentro del mismo fichero. Los ficheros son:
    Assert ctype errno float
    Limits locale math setjmp
    Signal stdarg stddef stdio
    Stdlib string time
    Podemos incluir todos los ficheros de cabecera como hagan falta.


    3.14 ENTRADA/SALIDA ESTANDAR
    Hasta ahora hemos visto el printf para la salida de datos por pantalla. Para la entrada de datos esta el scanf.
    Ambos permiten especificar formatos determinados por lo que se conoce como entrada/salida formateada.
    “C” proporcional mecanismos para leer/escribir un solo carácter. Son putchar o getchar.
    A. La función PRINTF
    Esta función imprime por pantalla según el formato que se le ponga. Estos formatos fueron ya vistos en el tema 2.
    B. La función SCANF
    Es la entrada de datos más utilizada. Permite también la utilización de formato
    Tanto el printf como el scanf están definidos en el fichero de cabecera stdio.h
    El formato es:
    Scanf (“cadena de control”, lista de argumentos);
    Formato variables
    Las variables deben ponerse como su dirección en donde van a almacenarse los datos. Para ello utiliza el &.
    Ej. Scanf (“%d”, &dato);
    C. Otras funciones de ENTRADA/SALIDA
    Existen otras funciones:
    o Getchar: Permite leer caracteres uno a uno.
    int getchar (void);
    o Putchar: Escribe caracteres uno a uno.
    int putchar(void);
    Hay otras funciones:
    o Getch: Lee un carácter sin que aparezca por pantalla.
    o Getche: Lee un carácter visualizándolo en pantalla.
    o Gets: Lee una cadena de caracteres.
    o Puts: Escribe una cadena de caracteres.

      Fecha y hora actual: Mar Oct 17, 2017 7:45 am