Funciones#

Introducción #

Las funciones son un componente fundamental de la programación de C++, empaquetando fragmentos de código en secciones de código reutilizables y eficientes diseñadas para realizar una tarea específica. Las funciones se pueden llamar varias veces dentro de un programa, lo que facilita la organización del código y ayuda a evitar la repetición del código. Las funciones también hacen que el código sea más fácil de depurar.

Esta página cubre los conceptos básicos del uso de funciones en C++, que incluyen:

Estructura y sintaxis de funciones: cómo se escriben las funciones en C++, incluidos los tipos, nombres y parámetros de retorno.
Prototipos de funciones — Qué son las funciones prototipo y por qué se utilizan.
Definición y llamada de funciones — Cómo crear funciones y llamarlas desde tu programa.
Devolver valores: cómo las funciones pueden enviar datos a la persona que llama.
Pasar por referencia — Cómo las funciones pueden modificar variables fuera de su propio alcance.
Funciones de devolución de llamada: cómo se pueden pasar funciones a otras funciones y llamar automáticamente en respuesta a eventos.
Funciones con argumentos predeterminados — Cómo se pueden dar valores predeterminados a los parámetros cuando no se proporciona ningún argumento.

Estructura y sintaxis de las funciones #

En C++, las funciones deben declararse con su tipo de retorno, nombre y parámetros. La sintaxis básica es:

return_type function_name(parameters) {
  // Code to execute when the function is called
  return result;  // Optional, used to return a value
}

Piezas de función	Descripción
`return_type`	El tipo de datos que devuelve la función, algunas opciones comunes son: `void` — No devuelve nada `int` — Devuelve un valor entero `double` — Devuelve un número de punto flotante `bool` — Devuelve `true` o `false` `char` — Devuelve un solo carácter `const char*` — Devuelve una cadena de texto tipos definidos por el usuario — Devuelve una `struct` u objeto de clase
`function_name`	El nombre de la función.
`parameters`	Opcional. Una lista separada por comas de parámetros escritos como nombre de `type name`, donde `type` especifica el tipo de datos del parámetro y `name` es el identificador utilizado para acceder a ese valor dentro de la función. Los parámetros reciben valores de entrada cuando se llama a la función.
`result`	Opcional. El valor devuelto por la función. Si el `return_type` es `return_type`, se debe proporcionar este valor y su tipo debe coincidir exactamente con el `void`.

Nota: Una función debe declararse siempre antes de que se llame, o debe proporcionar un prototipo de función.

Prototipos de funciones #

En C++, el código se lee de arriba a abajo. Esto significa que el compilador debe conocer una función antes de poder llamarla.

Un prototipo de función te permite usar una función antes de escribir su código completo. Esto le permite mantener main() cerca de la parte superior de su programa mientras coloca las definiciones de función más adelante, donde son más fáciles de organizar y leer.

Sin un prototipo, tendrías que definir todas las funciones por encima de main(), lo que puede hacer que los proyectos sean más difíciles de seguir a medida que crecen.

Definir el prototipo de la función (fuera de int main())
// The function's prototype
void greeting();
Llamar a la función dentro de int main()
int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  greeting();
}
Escribe el cuerpo de la función después
void greeting() {
  Brain.Screen.print("Hello!");
}

Definición y funciones de llamada #

Functions with No Parameters #

Si una función no requiere entrada, puede definirla sin parámetros. Utilice void como tipo de retorno si la función no devuelve un valor.

Definir la función (fuera de int main())

// Define a function to display a message
void greeting() {
    Brain.Screen.print("Hello!");
}

Llamar a la función dentro de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Call the function to display the message
  greeting();
}

Functions with Parameters #

También puede agregar parámetros a las funciones, que le permiten pasar información para que la función la use.

Nota: El texto se puede pasar usando cadenas de estilo C (const char*) o cadenas C++ (std::string).

Definir la función (fuera de int main())

// Define a function with a parameter
void namedGreeting(const char* name) {
    Brain.Screen.print("Hello, %s!", name);
}

Llamar a la función con un parámetro dentro de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Call the function to display the message
  namedGreeting("Stranger");
}

Valores de devolución #

Las funciones pueden enviar datos a la persona que llama utilizando la palabra clave return. Esto le permite capturar y utilizar el resultado en su proyecto.

Definir la función (fuera de int main())

// Define a function that multiplies numbers by 2
int timesTwo(int number) {
    return number * 2;
}

Llamar a la función con un parámetro dentro de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Display the return value
  Brain.Screen.print("%d", timesTwo(2));
}

Paso por Referencia #

De forma predeterminada, C++ pasa los parámetros de la función por valor, lo que significa que la función recibe una copia de la variable original. Los cambios realizados dentro de la función no afectan el valor original.

Definir la función (fuera de int main())

// Add 1 to the number
void addOne(int number) {
  number++;
}

Llamar a la función con un parámetro dentro de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  int value = 5;
  addOne(value);
  // "value" will still be 5
}

Para permitir que una función modifique la variable original, los parámetros se pueden pasar por referencia utilizando el símbolo &.

Definir la función (fuera de int main())

// Add 1 to the number
void addOne(int& number) {
  number++;
}

Llamar a la función con un parámetro dentro de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  int value = 5;
  addOne(value);
  // "value" will now be 6
}

Pasar por referencia permite que las funciones actualicen variables definidas fuera de la función sin devolver un valor.

Funciones de devolución de llamada #

Una función de devolución de llamada es una función que se pasa a otra función y se llama automáticamente cuando ocurre un evento específico.

Las devoluciones de llamada se utilizan comúnmente para eventos como pulsaciones de botones o actualizaciones de sensores.

En lugar de llamar a la función usted mismo, el proyecto la llama cuando ocurre el evento.

Defina la función de devolución de llamada (fuera de int main())

// Create a callback function
void onPressed() {
  Brain.Screen.print("Screen pressed!");
}

Registrar la devolución de llamada dentro de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Call onPressed whenever the screen is pressed
  Brain.Screen.pressed(onPressed);
}

Callback Signatures #

Cada función de devolución de llamada debe seguir una firma específica, que define:

El tipo de devolución
El número de parámetros
Los tipos de parámetros

La API determina la firma requerida. La función de devolución de llamada debe coincidir exactamente con esta firma.

// This callback function cannot include any parameters
void callback(void);

// This callback function includes four parameters
void callback(axisType axis, double x, double y, double z);

Los nombres de los parámetros son descriptivos y pueden variar, pero el tipo de retorno, el orden de los parámetros y los tipos de parámetros deben coincidir exactamente.

Funciones con argumentos predeterminados #

Las funciones pueden definir valores predeterminados para uno o más parámetros. Se utiliza un argumento predeterminado cuando no se proporciona ningún valor para ese parámetro cuando se llama a la función.

Reglas para los argumentos predeterminados:

Los argumentos predeterminados deben ser los últimos parámetros en la definición de la función.
Una vez que un parámetro tiene un valor predeterminado, todos los parámetros posteriores también deben tener valores predeterminados.
Si una función especifica argumentos predeterminados en su prototype, esos valores predeterminados no deben especificarse nuevamente en la definición de la función.

Definir la función (fuera de int main())

// Required parameter first, default parameter last
void greeting(const char* name, int repeatCount = 1) {

    for (int i = 0; i < repeatCount; i++) {
        Brain.Screen.print("Hello, %s!", name);
        Brain.Screen.newLine();
    }
}

Llamar a la función dentro de int main()

int main() {
  /* vexcodeInit() is only required when using VEXcode.
  Remove vexcodeInit() if compiling in VS Code. */
  vexcodeInit();

  // Say what name to greet (EXP) and
  // use default value for repeatCount (1)
  greeting("EXP");

  Brain.Screen.newLine();

  // Overrides the default value to 3
  greeting("EXP", 3);
}

// Required parameter first, default parameter last
void greeting(const char* name, int repeatCount = 1) {

    for (int i = 0; i < repeatCount; i++) {
        Brain.Screen.print("Hello, %s!", name);
        Brain.Screen.newLine();
    }
}

int main() {
    vexcodeInit();

    // Say what name to greet (EXP) and
    // use default value for repeatCount (1)
    greeting("EXP");

    Brain.Screen.newLine();

    // Overrides the default value to 3
    greeting("EXP", 3);
}