Saltar al contenido principal
LibreTexts Español

3.3: Funciones

  • Page ID
    82395
  • \( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \) \( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)\(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\) \(\newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\) \( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\) \( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\) \( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\) \( \newcommand{\Span}{\mathrm{span}}\)\(\newcommand{\AA}{\unicode[.8,0]{x212B}}\)

    Las funciones utilizan las mismas reglas de nomenclatura que las variables. Todas las funciones usan la misma plantilla que se parece a esto:

    Código\(\PageIndex{1}\) (C): Basic function template.

    return_value function_name( function argument list )
    {
        statement(s)
    }
    

    Se podría pensar en la función en el sentido matemático. Es decir, le das algún valor (s) y te devuelve un valor. Por ejemplo, tu calculadora tiene una función sinusoidal. Le envías un ángulo y te devuelve un valor. En C, las funciones pueden tener varios argumentos, no sólo uno. Quizá ni siquiera tengan una discusión. Además, las funciones C pueden devolver un valor, pero no tienen que hacerlo. Las “tripas” de la función se definen dentro del par de corsé de apertura y cierre {}. Entonces, una función que toma dos enteros, x e y, como argumentos, y devuelve un valor de coma flotante se verá así:

    float my_function( int x, int y )
    {
        //...appropriate statements here...
    }
    

    Si la función no toma ni devuelve valores, se usa la palabra void. Si una función no requiere valores ni devuelve un valor, se vería así:

    void other_function( void )
    {
        //...appropriate statements here...
    }
    

    Esto puede parecer un trabajo extra quisquilloso al principio, pero la lista de tipos de datos tiene mucho sentido porque C tiene algo llamado verificación de tipos. Esto significa que si intentas enviar a una función el tipo incorrecto de variable, o incluso el número incorrecto de variables, ¡el compilador te advertirá que has cometido un error! Así, si intentas enviar my_function () por encima de dos flotadores o tres enteros, el compilador se quejará y te ahorrará un gran dolor de cabeza durante las pruebas.

    Todos los programas deben tener un lugar para comenzar, y en C, la ejecución del programa comienza con una función llamada main. Esta no tiene que ser la primera función escrita o listada, sino que todos los programas deben tener una función llamada main. Aquí está nuestro primer programa, que se encuentra en Código\(\PageIndex{2}\), siguiente:

    Código\(\PageIndex{2}\) (C): A simple program.

    /* Our first program */
    
    void main( void )
    {
        float x = 2.0;
        float y = 3.0;
        float z;
        
        z = x*y/(x+y);
    }
    

    Aquí sólo hay una función, main (). No toma variables y no devuelve nada. ¿Qué son las otras cosas? Primero, el par /* */ denota un comentario 1. Cualquier cosa dentro del par de comentarios es ignorada por el compilador. Un comentario en C puede estirarse por muchas líneas. Una vez dentro de la función, se declaran tres variables con dos de ellas dadas valores iniciales. A continuación, las variables x e y se multiplican juntas, divididas por su suma, y se asignan a z. Como C es de flujo libre, una versión equivalente (pero fea) es:

    Código\(\PageIndex{3}\) (C): Alternate format (to be avoided).

    /* Our first program */ void main(void){
    float x=2.0;float y=3.0;float z;z=x*y/(x+y);}
    

    Esto es todo lo contrario de Python que tiene reglas de espaciado y formato muy rígidas.

    Ahora, supongamos que esta operación de sumar, multiplicar, dividir es algo que hay que hacer mucho. Podríamos dividir esto en una función separada. Nuestro programa ahora se parece a Código\(\PageIndex{4}\):

    Código\(\PageIndex{4}\) (C): Program with separate function.

    /* Our second program */
    
    float add_mult_div( float a, float b )
    {
        float answer;
        
        answer = a*b/(a+b);
        return( answer );
    }
    
    void main( void )
    {
        float x = 2.0;
        float y = 3.0;
        float z;
    
        z = add_mult_div( x, y );
    }
    

    La nueva función matemática toma dos float s como argumentos y devuelve un float a la persona que llama. El compilador ve la nueva función antes de que se use en main (), así, ya “sabe” que se le deben enviar dos float s y que el valor de retorno debe asignarse a un float. Es muy importante señalar que la nueva función matemática utiliza diferentes nombres de variables (a y b) de la persona que llama (x e y). Las variables en la nueva función matemática son realmente solo colocadoras. Los valores de la llamada original (x e y) se copian a estas nuevas variables (a y b) y se utilizan dentro de la nueva función. Al ser copias, pueden ser alteradas sin cambiar los valores originales de x e y. En este caso, se dice que x e y son locales para la función main () mientras que a y b son locales para la función add_mult_div (). En otras palabras, a no es visible desde main () ¡así que no puedes alterarlo accidentalmente! Del mismo modo, x no es visible desde add_mult_div (), por lo que tampoco puedes alterarlo accidentalmente. Esto es una ventaja positiva cuando se trata de programas grandes que utilizan muchos nombres de variables. Si bien no suele preferirse, hay momentos en los que quieres que una variable sea conocida “en todas partes”. A estos se les llama ítems globales. Puedes hacer que las variables sean globales simplemente declarándolas al inicio del programa fuera de las funciones (es decir, justo después de ese comentario inicial en nuestro ejemplo).


    1. C también permite//denotar un comentario de una sola línea sin el “emparejamiento de backend”.

    This page titled 3.3: Funciones is shared under a CC BY-NC-SA 4.0 license and was authored, remixed, and/or curated by James M. Fiore via source content that was edited to the style and standards of the LibreTexts platform; a detailed edit history is available upon request.