(1) En una computadora, una subrutina es una cierta parte del código en un programa grande, que consta de uno o más bloques de instrucciones. Es responsable de completar una tarea específica y es relativamente independiente de otros códigos.

(2) En general, hay parámetros de entrada y valores de retorno que proporcionan la encapsulación del proceso y la ocultación de detalles.

2. Clasificación de funciones

(1) Funciones de la biblioteca

(2) Funciones personalizadas

2. Funciones de biblioteca y funciones personalizadas

1. Funciones de la biblioteca

(1) ¿Qué es una función de biblioteca?

Cuando generalmente aprendemos el lenguaje C, a menudo usamos funciones con algunas funciones, como printf (función de salida formateada, el formato de la última letra f) que generalmente quiere imprimir el resultado en la pantalla, obtener scanf de entrada de teclado y calcular caracteres strlen para longitud de la cuerda.

Los que completan ciertas funciones básicas anteriores no son códigos comerciales, pero a menudo son utilizados por cada uno de nuestros programadores.

Por lo tanto, para mejorar nuestra eficiencia de trabajo habitual, se proporcionan algunas funciones de biblioteca similares en la biblioteca básica del lenguaje C, que es conveniente para que los programadores desarrollen software.

Las funciones de biblioteca generalmente se especifican en el estándar de lenguaje C y las implementan los fabricantes de compiladores.

(2) ¿Cómo aprender las funciones de la biblioteca?

muy recomendable

En primer lugar, ingresamos a www.cplusplus.com y hacemos clic en REFERENCIA como se muestra en la figura

En la Biblioteca C, verá que a menudo usamos archivos de encabezado como stdio.h, etc.

Haga clic para ingresar y verá algunas funciones de uso común en la columna de la izquierda.

Continúe haciendo clic para ver la explicación detallada de la función, como se muestra en la figura

Un breve resumen de las funciones de la biblioteca: Funciones comunes de la biblioteca:

función de E/S
funciones de operador de caracteres
funciones de operador de cadena
función de manipulación de memoria
función matemática
funciones de hora/fecha
otras funciones

Nota: cuando utilice funciones de biblioteca, asegúrese de incluir los archivos de encabezado correspondientes a #include, y no olvide

2. Funciones personalizadas

Una función personalizada es lo mismo que una función, con un nombre de función , un tipo de valor devuelto y parámetros de función

La forma de definición de la función.

ret_type fun_name(para1, * )
{
statement;//语句项
}
ret_type 返回类型
fun_name 函数名
para1   函数参数

类型说明符 函数名( 形参类型 参数1，形参类型 参数2,......)
{
    stamens；
    //语句项
    
}

(1) [Dé un ejemplo]

Escribe una función que encuentre el máximo de dos números.

#include <stdio.h>
//get_max函数的设计
int get_max(int x, int y)
{
    return (x>y)?(x):(y);
}
int main()
{
    int num1 = 10;
    int num2 = 20;
    int max = get_max(num1, num2);
    printf("max = %d\n", max);
    return 0;
}

(2) Otro ejemplo [aquí viene el punto clave]

Escribe una función que intercambie dos variables enteras

//实现成函数，但是不能完成任务
void Swap1(int x, int y)
{
	int tmp = 0;
	tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int num1 = 1;
	int num2 = 2;
	Swap1(num1, num2);
	printf("Swap1::num1 = %d num2 = %d\n", num1, num2);
	return 0;
}

Tenga en cuenta que hay un problema con el código, hay un error en la comprensión de los parámetros, consulte el código correcto a continuación

#include <stdio.h>
//正确的版本
void Swap2(int* px, int* py)
{
	int tmp = 0;
	tmp = *px;
	*px = *py;
	*py = tmp;
}
int main()
{
	int num1 = 1;
	int num2 = 2;
	Swap2(&num1, &num2);
	printf("Swap2::num1 = %d num2 = %d\n", num1, num2);
	return 0;
}

A continuación, los parámetros de la función explican los parámetros en detalle.

3. Parámetros de función

1. Parámetros reales (parámetros reales)

Parámetro real: el parámetro realmente pasado a la función (es decir, el argumento en matemáticas).

Los parámetros pueden ser: constantes, variables, expresiones, funciones, etc.

Sin embargo, cuando se llama a la función, deben tener un valor definido para poder pasar a los parámetros formales.

En el código de suma anterior

2. Parámetros formales (parámetros formales)

Los parámetros formales se refieren a las variables entre paréntesis después del nombre de la función , porque los parámetros formales solo se instancian (unidades de memoria asignadas) cuando se llama a la función, por lo que se denominan parámetros formales.

Los parámetros formales se destruyen automáticamente cuando se completa la llamada a la función. Por lo tanto, los parámetros formales solo son válidos dentro de la función.

Resumen: después de instanciar el parámetro formal, es equivalente a una copia temporal del parámetro real

En cuarto lugar, la llamada a la función

1. Llame por valor

Los parámetros formales y los parámetros reales de la función ocupan diferentes bloques de memoria, y la modificación de los parámetros formales no afectará a los parámetros reales.

Cuando escribimos una función, escriba una función add () que imprima la suma de dos números, luego la llamada a la función necesita dos valores, aquí, por ejemplo, pase la suma de 3 y 5, luego agregue (3,5)

2. Llamar por dirección

(1) La llamada por dirección es un método para llamar a una función pasando la dirección de memoria de la variable creada fuera de la función al parámetro de función.

(2) Este método de pasar parámetros puede establecer una conexión real entre la función y las variables fuera de la función, es decir, las
variables fuera de la función pueden manipularse directamente dentro de la función.

Entonces, en el código anterior que intercambia dos números, la función debe llamarse por referencia para modificar el valor de la variable externa.

(3) Ejercicios de función

1. Escribe una función para determinar si un número es primo o no.

#include <stdio.h>
int Is_prime(int n) 
{
	int i = 0;
	for (i = 2; i < n;i++)
	{
		if (n%i == 0)
		{
			return 0;//不是素数返回0
		}
	}
	return 1;//for循环完成后，如果是素数返回1
}
int main() 
{
	int n = 0;
	scanf("%d",&n);
	if (Is_prime(n))
		printf("%d is prime", n);
	else
		printf("%d is not prime", n);
	return 0;
}

Un número primo es un entero positivo que solo puede ser divisible por 1 y por sí mismo, por lo que no es un número primo que pueda ser divisible por otros números (excluyendo 1 y él mismo).Para ampliar, un número es divisible por otros números.

Por ejemplo, 16, 16 = 2 * 8; 16 = 4 * 4; 16 = 8 * 2; aquí podemos ver que un número no es un número primo para calcular 2, 4, 8

De hecho, solo necesita ser calculado $\sqrt[]{16} = 4$ , porque si uno de 2*8 y 8*2 satisface, entonces no es un número primo. En la medida en que i <= la raíz cuadrada de un número, i<= $\sqrt[]{n}$ . De acuerdo con este principio, el siguiente código es

metodo de numeros primos dos

#include <stdio.h>
#include <math.h>
int Is_prime(int n)
{
	int i = 0;
	for (i = 2; i <=sqrt(n); i++)
	{
		if (n % i == 0)
		{
			return 0;
		}
	}
	return 1;
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	if (Is_prime(n))
		printf("%d is prime", n);
	else
		printf("%d is not prime",n);
	return 0;
}

2. Escribe una función para determinar si un año es bisiesto o no.

#include <stdio.h>
int is_leap_year(int y)
{
	if (y % 4 == 0 && y % 100 != 0 || y % 400 == 0)
		return 1;
	else
		return 0;

}
int main() 
{
	int y = 0;
	scanf("%d",&y);
	if (is_leap_year(y))
		printf("%d is leap year\n", y);
	else
		printf("%d is not leap year\n",y);

	return 0;
}

Los años bisiestos ordinarios se refieren a los años del calendario gregoriano que son múltiplos de 4 y no de 100, mientras que los años bisiestos de siglo deben ser múltiplos de 400.

3. Escriba una función para implementar la búsqueda binaria de una matriz ordenada de enteros.

#include <stdio.h>
int binary_search(int arr[],int num ,int sz)
{
	int left = 0;
	int right = sz - 1;
	int mid = 0;
	while (left<=right)
	{
		mid = (left + right) / 2; //可以优化为mid = left+(right-left)/2;
		if (arr[mid]>num)
		{
			right = mid - 1;
		}
		else if (arr[mid]<num)
		{
			left = mid + 1;
		}
		else 
		{
			return mid;
		}
	}
	return -1;
}
int main() 
{
	int arr[] = {1,2,3,4,5,6,7,8,9,10};
	int num = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);//数组元素的个数
	scanf("%d",&num);	//输入一个要查找的数
	int ret = binary_search(arr, num, sz);
	if (ret != -1)
		printf("找到了，该数下标为：%d",ret);
	else
		printf("没有找到 ！");
	
}

4. Escribe una función que aumente el valor de num en 1 cada vez que se llama a la función.

#include <stdio.h>
void add(int * p)
{
	*p = *p + 1;
}
int main() 
{
	int num = 0;
	add(&num);//调用第一次，调用传的是地址
	printf("%d\n",num);
	add(&num);//第二次
	printf("%d\n",num);
	add(&num);//第三次
	printf("%d\n",num);
	return 0;
}

5. Llamada anidada y acceso encadenado de funciones

1. Llamadas de funciones anidadas

Las funciones se pueden llamar entre sí. Tenga en cuenta que las funciones se pueden anidar, pero no anidar.

#include<stdio.h>
void test3() 
{
	printf("666\n");
}
void test1() 
{
	int i = 0;
	while (i < 3)
	{
		test3();
		i++;
	}
}
int main() 
{
	test1();
	return 0;
}

2. Cadena de acceso

Usar el valor de retorno de una función como argumento para otra función

#include <stdio.h>
int main()
{
  printf("%d", printf("%d", printf("%d", 43)));
  //注：printf函数的返回值是打印在屏幕上字符的个数
  return 0;
}

El resultado es: 4321

6. Declaración y definición de funciones

1. Declaración de función

#include<stdio.h>
int add(int x, int y);

Dígale al compilador cómo se llama una función, cuáles son sus parámetros y cuál es su tipo de retorno . Pero si existe o no, la
declaración de la función no puede decidir.
La declaración de una función generalmente aparece antes del uso de la función. Debe declararse antes de su uso .
Las declaraciones de funciones generalmente se colocan en archivos de encabezado.

2. Definición de función

La definición de una función se refiere a la realización específica de la función, explicando la realización de la función de la función.

//函数的实现
int add(int x,int y)
{
    return x + y;
}

Siete, función de recursividad e iteración.

1. ¿Qué es la recursividad?

recursión + regresión

Una técnica de programación en la que un programa se llama a sí mismo se llama recursividad.

La recursión es ampliamente utilizada como algoritmo en lenguajes de programación.
Un proceso o función tiene un método para llamarse a sí mismo directa o indirectamente en su definición o descripción . Suele transformar un problema grande y complejo capa por capa en un problema de menor escala similar al problema original a resolver, estrategia recursiva. Solo una pequeña cantidad de programas puede describir los múltiples cálculos repetidos necesarios en el proceso de resolución de problemas, lo que reduce en gran medida la cantidad de código en el programa. Idea central: hacer pequeñas las cosas grandes

2. Dos condiciones necesarias para la recursividad

Hay restricciones, y cuando las condiciones cumplen con las restricciones, la recursividad se detiene.
Después de cada recursión, está cerca de esta restricción

[Ejemplo] (1) Acepte un valor entero (sin signo) e imprima cada bit en orden

#include <stdio.h>
void print(int n)
{
	if (n>9)		//限制条件
	{
		print(n/10);	//每次递归越来越接近这个限制条件
	}
	printf("%d ",n%10);	//打印n 的每一位
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	print(n);
	return 0;
}

Diagrama donde 5 -> 6 -> 7 -> 8 es el orden de impresión 2 0 2 3

[Ejemplo] (2) Escribir una función no permite la creación de variables temporales, encuentre la longitud de la cadena

#include <stdio.h>
int Strlen(char* str)
{
	if (*str == '\0')
		return 0;
	else
		return 1 + Strlen(str+1);//如果还有字符就继续递归判断下一个字符
}
int main()
{
	char *str = "abc";
	int len = Strlen(str);
	printf("%d\n",len);
	return 0;
}

【Ilustración】 Siga las flechas y los pasos para observar con paciencia y ganará mucho

3. Recursión e iteración

La iteración también puede entenderse como un bucle.

[Ejemplo] Encuentra el n-ésimo número de Fibonacci (sin considerar el desbordamiento)

Números de Fibonacci 1 1 2 3 5 8 13 21 ...... El primer y segundo número son 1, y el último elemento es igual a la suma de los dos primeros elementos

El siguiente código se implementa recursivamente

#include <stdio.h>
int fib(int n)
{
	if (n <= 2)
		return 1;
	else
		return fib(n - 1) + fib(n - 2);
}
int main()
{
	int n = 0;
	scanf("%d",&n);
	int ret = fib(n);
	printf("%d\n", ret);
	return 0;
}

Sin embargo, habrá ciertos problemas al escribir de esta manera, es decir, lleva mucho tiempo calcular los números de Fibonacci después del 50, y si intenta encontrar un número muy grande, puede ocurrir un desbordamiento de pila.

Debido a que el espacio de pila asignado por el sistema al programa es limitado, es probable que ocurran bucles infinitos (recurrencia muerta), lo que puede conducir al
desarrollo continuo del espacio de pila y, finalmente, el espacio de pila se agotará. Desbordamiento.

Para resolver el problema anterior puedes usar

recursivo a no recursivo
Utilice objetos estáticos en lugar de objetos locales no estáticos.

La siguiente es una forma no recursiva de lograr

#include<stdio.h>
int fib(int n ) 
{
	int a = 1;
	int b = 1;
	int c = 1;
	while (n>2)
	{
		c = a + b;
		a = b;
		b = c;
		n = n - 1;
	}
	return c;
}
int main() 
{
	int n = 0;
	scanf("%d", &n);
	int ret = fib(n);
	printf("%d\n",ret);
	return 0;
}

Entonces, por lo general, es fácil pensar en la recursividad, y la recursividad se puede usar cuando no hay errores obvios.

[Lenguaje C] Función Explicación detallada

1. Definición de funciones y clasificación de funciones

1. Definición de función