Funciones#

Introducción#

Las funciones son un componente fundamental de la programación en C++, ya que empaquetan fragmentos de código en secciones reutilizables y eficientes, diseñadas para realizar una tarea específica. 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. Además, facilitan la depuración del código.

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

Estructura y sintaxis de 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
}

Partes funcionales

Descripción

return_type

The data type that the function returns, some common options are:

  • void — Returns nothing
  • int — Returns an integer value
  • double — Returns a floating-point number
  • bool — Returns true or false
  • char — Returns a single character
  • const char* — Returns a text string
  • user-defined types — Returns a struct or class object

function_name

El nombre de la función.

parameters

Optional. A comma-separated list of typed parameters written as type name, where type specifies the data type of the parameter and name is the identifier used to access that value inside the function. Parameters receive input values when the function is called.

result

Optional. The value returned by the function. If the function’s return_type is not void, this value must be provided and its type must exactly match the specified return_type.

Nota: Una función debe siempre ser declarada antes de ser llamada, 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.

A function prototype lets you use a function before writing its full code. This allows you to keep main() near the top of your program while placing function definitions later, where they are easier to organize and read.

Without a prototype, you would have to define every function above main(), which can make projects harder to follow as they grow.

// The function's prototype
void greeting();

int main() {
  greeting();
}

// Write the function's body after
void greeting() {
  Brain.Screen.print("Hello!");
}

Definición y llamada de funciones#

Functions with No Parameters#

If a function does not require input, you can define it without parameters. Use void as the return type if the function doesn’t return a value.

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

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    vexcodeInit();
    // Call the function to display the message
    greeting();
}

Functions with Parameters#

También puedes agregar parámetros a las funciones, lo que te permite pasar información para que la función la utilice.

Note: Text can be passed using C-style strings (const char*) or C++ strings (std::string).

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

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    vexcodeInit();
    namedGreeting("Stranger");
}

Valores de retorno#

Functions can send data back to the caller using the return keyword. This allows you to capture and use the output in your project.

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

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    vexcodeInit();
    // Display the return value
    Brain.Screen.print("%d", timesTwo(2));
}

Pasando por referencia#

De forma predeterminada, C++ pasa los parámetros de una 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.

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

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

To allow a function to modify the original variable, parameters can be passed by reference using the & symbol.

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

int main() {
  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 llamadas 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 por usted cuando ocurre el evento.

void onPressed() {
  Brain.Screen.print("Screen pressed!");
}

// Call onPressed whenever the screen is pressed
int main() {
  vexcodeInit();
  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 retorno

  • 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 al llamar a la función.

Reglas para 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 prototipo, esos valores predeterminados no deben especificarse nuevamente en la definición de la función.

// 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 (V5) and
    // use default value for repeatCount (1)
    greeting("V5");

    Brain.Screen.newLine();

    // Overrides the default value to 3
    greeting("V5", 3);
}
En esta página