Saltar al contenido

Consejos funcionales en la programación C con ejemplos

Las sugerencias son una gran posibilidad para las funciones ‘C’ que se limitan a que devolvamos un valor. Con los parámetros de puntero, nuestras funciones ahora pueden procesar datos reales en lugar de copiar datos.

Para modificar los valores reales de las variables, la instrucción de llamada a la dirección ingresa en los parámetros del puntero.

En este tutorial, aprenderá:

Sugerencias de funciones de ejemplo

Por ejemplo, intercambie el siguiente programa dos valores de dos:


void swap (int *a, int *b);
int main() {
  int m = 25;
  int n = 100;
  printf("m is %d, n is %dn", m, n);
  swap(&m, &n);
  printf("m is %d, n is %dn", m, n);
  return 0;}
void swap (int *a, int *b) {
  int temp;
  temp = *a;
  *a = *b;
  *b = temp;}
}

Producción:


m is 25, n is 100
m is 100, n is 25

El programa intercambia los valores reales de las variables porque la función accede a ellas lanzándolas usando punteros. Aquí discutiremos el proceso de programación:

  1. Declaramos la función responsable de intercambiar los dos valores variables, que toman dos puntos enteros como parámetros y devuelven cualquier valor cuando se llaman.
  2. En la función principal, declaramos e iniciamos dos variables enteras (‘m’ y ‘n’) y luego imprimimos sus valores respectivamente.
  3. Llamamos a la función de intercambio () pasando la dirección de las dos variables como argumentos usando el símbolo comercial. A continuación, imprimimos los valores de intercambio de nuevas variables.
  4. Aquí definimos la función de intercambio () que toma dos direcciones de variables enteras como parámetros y declara una variable entera temporal utilizada como un tercer cuadro de almacenamiento para guardar una de las variables de valor que se agregarán a la segunda variable.
  5. Guarde el contenido de la primera variable mencionada con ‘a’ en la variable temporal.
  6. Almacene la segunda variable apuntada por b en la primera variable apuntada por a.
  7. Actualice la segunda variable (puntuada por b) de acuerdo con el valor de la primera variable guardada en la variable temporal.

Funciones con parámetros de matriz

IC, no podemos editar por valor a una función. Debido a esto, un nombre de matriz es un puntero (dirección), por lo que solo colocamos un nombre de matriz en una función que significa reenviar un puntero a la matriz.

Por ejemplo, consideramos el siguiente programa:


int add_array (int *a, int num_elements);
int main() {
  int Tab[5] = {100, 220, 37, 16, 98};
  printf("Total summation is %dn", add_array(Tab, 5)); 
  return 0;}
int add_array (int *p, int size) {
  int total = 0;
  int k;
  for (k = 0; k < size; k++) {
    total += p[k];  /* it is equivalent to total +=*p ;p++; */}
 return (total);}

Producción:

 Total summation is 471

Aquí, explicaremos el código del programa con sus detalles.

  1. Declaramos y definimos una función add_array () que toma la dirección de la matriz (puntero) de su número de elemento como parámetros y devuelve la suma total acumulada de estos elementos. El puntero se usa para repetir los elementos de la matriz (usando la p[k] notación), y acumulamos la suma en una variable local que se devuelve después de repetir la matriz de todo el elemento.
  2. Declaramos y comenzamos un conjunto de números enteros con cinco elementos enteros. Imprimimos la suma total enviando el nombre de la matriz (que actúa como una dirección) y el tamaño de la matriz a la add_array ()llamada función como argumentos.

Matriz de funciones de retorno

IC, podemos devolver un puntero a una matriz, como en el siguiente programa:


#include <stdio.h>
int * build_array();
int main() {
  int *a;
  a = build_array(); /* get first 5 even numbers */
  for (k = 0; k < 5; k++)
    printf("%dn", a[k]);
  return 0;}
int * build_array() {
  static int Tab[5]={1,2,3,4,5};
   return (Tab);}

Producción:


1
2
3
4
5

Y aquí, discutiremos los detalles del programa.

  1. Definimos y declaramos una función que da una dirección de matriz que contiene un valor entero y no ha tomado ningún argumento.
  2. Declaramos un puntero entero que encuentra la matriz completa tomada después de llamar a la función e imprimimos su contenido repitiendo toda la matriz de cinco dimensiones.

Tenga en cuenta que se define un puntero, no una matriz, para almacenar la dirección de matriz que devuelve la función. Tenga en cuenta también que al devolver una variable local de una función, debemos declarar que es estática en la función.

Consejos de función

Como sabemos, por definición, los avisos prestan atención a la dirección en cualquier ubicación de la memoria, también pueden referirse al comienzo del código ejecutable como funciones en la memoria.

Se declara que un puntero funciona con *, la declaración de declaración general es:


return_type (*function_name)(arguments) 

Debe recordar que los paréntesis alrededor (* function_name) son importantes porque sin ellos, el compilador asumirá que function_name está devolviendo un puntero return_type.

Después de definir el puntero de función, necesitamos asignarlo a una función. Por ejemplo, el siguiente programa declara una función normal, define un puntero de función, asigna un puntero de función a la función normal y luego llama a la función a través del puntero:


#include <stdio.h>
void Hi_function (int times); /* function */
int main() {
  void (*function_ptr)(int);  /* function pointer Declaration */
  function_ptr = Hi_function;  /* pointer assignment */
  function_ptr (3);  /* function call */
 return 0;}
void Hi_function (int times) {
  int k;
  for (k = 0; k < times; k++) printf("Hin");} 

Producción:


Hi
Hi
Hi
  1. Definimos y declaramos una función estándar que a veces imprime texto Hi kk que se indica mediante el parámetro times cuando se llama a la función
  2. Definimos una función de puntero (con su declaración especial) que toma un parámetro entero y no devuelve nada.
  3. Primero colocamos nuestra función de puntero con Hi_function, lo que significa que el puntero apunta a Hi_function ().
  4. En lugar de llamar a la función estándar tocando el nombre de la función con argumentos, solo llamamos a la función de puntero pasando el número 3 como argumentos, ¡y eso es todo!

Tenga en cuenta que el nombre de la función se centra en la dirección inicial del código ejecutable como un nombre de matriz que se centra en su primer elemento. Por lo tanto, instrucciones como function_ptr = & hi_function y (* funptr) (3) son correctas.

NOTA: No es importante ingresar el operador de dirección y el operador de indirección * durante la tarea funcional y la llamada.

Un conjunto de sugerencias de funciones

Un conjunto de indicaciones puede desempeñar una función de cambio o un papel si una declaración para tomar una decisión, como en el siguiente programa:


#include <stdio.h>
int sum(int num1, int num2);
int sub(int num1, int num2);
int mult(int num1, int num2);
int div(int num1, int num2);

int main() 
{  int x, y, choice, result;
  int (*ope[4])(int, int);
  ope[0] = sum;
  ope[1] = sub;
  ope[2] = mult;
  ope[3] = div;
  printf("Enter two integer numbers: ");
  scanf("%d%d", &x, &y);
  printf("Enter 0 to sum, 1 to subtract, 2 to multiply, or 3 to divide: ");
  scanf("%d", &choice);
  result = ope[choice](x, y);
  printf("%d", result);
return 0;}

int sum(int x, int y) {return(x + y);}
int sub(int x, int y) {return(x - y);}
int mult(int x, int y) {return(x * y);}
int div(int x, int y) {if (y != 0) return (x / y); else  return 0;}

Enter two integer numbers: 13 48
Enter 0 to sum, 1 to subtract, 2 to multiply, or 3 to divide: 2
624

Aquí, discutimos los detalles del programa:

  1. Declaramos y definimos cuatro funciones que toman dos argumentos enteros y devuelven un valor entero. Estas funciones suman, restan, multiplican y dividen los dos argumentos de la función que llama el usuario.
  2. Declaramos 4 enteros para manejar óperas, tipo de operación y resultado respectivamente. Además, declaramos un conjunto de punteros de cuatro funciones. Cada puntero toma una función del elemento de matriz de dos parámetros enteros y devuelve un valor entero.
  3. Asignamos cada elemento de la matriz y comenzamos con la función ya declarada. Por ejemplo, el tercer elemento para el cual el puntero de la tercera función dirigirá una función de operación de multiplicación.
  4. Buscamos óperas y tipo de operación por parte del usuario tecleado con el teclado.
  5. Agregamos el elemento de matriz apropiado (puntero de función) a los argumentos y almacenamos el resultado que genera la función adecuada.

La guía int (* ope[4]) (int, int); se define el conjunto de mensajes de función. Cada elemento de la matriz debe tener los mismos parámetros y tipo de retorno.

Resultado de la declaración = ope[choice](x, y); la función apropiada se ejecuta a elección del usuario. Los dos números enteros ingresados ​​son los argumentos que se envían a la función.

Funciones que utilizan puntas vacías

Las solicitudes vacías se utilizan durante las declaraciones de funciones. Usamos permisos de retorno de tipo nulo * para devolver cualquier tipo. Si asumimos que nuestro parámetro no cambia al entrar en una función, lo declaramos estable.

Por ejemplo:

 void * cube (const void *); 

Considere el siguiente programa:


#include <stdio.h>
void* cube (const void* num);
int main() {
  int x, cube_int;
  x = 4;
  cube_int = cube (&x);
  printf("%d cubed is %dn", x, cube_int);
  return 0;}

void* cube (const void *num) {
  int result;
  result = (*(int *)num) * (*(int *)num) * (*(int *)num);
  return result;}

Resultado:

 4 cubed is 64 

Aquí, discutiremos los detalles del programa:

  1. Definimos y declaramos una función que devuelve un valor entero y da una dirección de variable invariante sin un tipo de datos específico. El valor del cubo de la variable sujeto (x) es señalado por el puntero num, y debido a que es un puntero nulo, lo escribimos en un tipo de datos entero usando un puntero de notación específico (* tipo de datos), y devolvemos el valor del cubo.
  2. Afirmamos la ópera y la variable resultado. Además, comenzamos nuestro trabajador con un valor de “4”.
  3. Llamamos a la función del cubo pasando la dirección del operando, y manejamos el valor de retorno en la variable de rendimiento.

Los consejos funcionan como argumentos

Otra forma de explotar un puntero de función es reenviarlo como un argumento a otra función a veces llamada “función de recuperación” porque la función receptora la llama “retorno”.

En el archivo de encabezado stdlib.h, la función de ordenación rápida “qsort ()” utiliza esta técnica, que es un algoritmo dedicado a la ordenación.


void qsort(void *base, size_t num, size_t width, int (*compare)(const void *, const void *)) 

El siguiente programa ordena una serie entera de números pequeños a grandes usando la función qsort ():


#include <stdio.h>
#include <stdlib.h>
int compare (const void *, const void *); 
int main() {
  int arr[5] = {52, 14, 50, 48, 13};
  int num, width, i;
  num = sizeof(arr)/sizeof(arr[0]);
  width = sizeof(arr[0]);
  qsort((void *)arr, num, width, compare);
  for (i = 0; i < 5; i++)
    printf("%d ", arr[ i ]);
  return 0;}

int compare (const void *elem1, const void *elem2) {
  if ((*(int *)elem1) == (*(int *)elem2))  return 0;
  else if ((*(int *)elem1) < (*(int *)elem2)) return -1;
  else return 1;}

Resultado:

 13 14 48 50 52 

Aquí, discutiremos los detalles del programa:

  1. Definimos una función de comparación que consta de dos argumentos y devuelve 0 cuando los argumentos tienen el mismo valor, <0 nuair a thagann arg1 roimh arg2, agus> 0 cuando arg1 viene después de arg2. Los parámetros que se agregan al tipo de datos de matriz relevante son punteros nulos. (entero)
  2. Definimos e iniciamos una matriz de enteros El tamaño de la edición se almacena en el num La variable y el tamaño de cada elemento de la matriz se almacenan en variables de ancho utilizando el operador predefinido C sizeof ().
  3. Llamamos al qsort función y pasar el nombre de la matriz, el tamaño, el ancho y la función de comparación previamente definida por el usuario para ordenar nuestra matriz en orden ascendente. La comparación se realizará construyendo dos elementos de matriz hasta que se ordene todo el conjunto.
  4. Imprimimos los elementos de la matriz para asegurarnos de que nuestra matriz esté bien ordenada repitiendo toda la matriz utilizando bucles.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *