parámetros predeterminados de la función
Los parámetros formales en la lista de parámetros formales de la función pueden usar valores predeterminados
Uso: devolver tipo de valor nombre de función (tipo de parámetro nombre de parámetro = valor predeterminado) {}
He aquí un ejemplo:
int demo(int a = 1, int b = 2)
{
return a + b;
}
int c = demo();
cout << "c = " << c << endl;
producción:
c = 3
Cuando llamamos a una función y especificamos el valor de la variable relevante, el valor que especificamos se usa en la función en lugar del valor predeterminado. Si no se especifica ningún valor asociado, se utiliza el valor predeterminado al llamar a la función. Las castañas son las siguientes:
int demo(int a = 1, int b = 2)
{
return a + b;
}
int a = 10;
int b = 20;
int c = demo(a, b);
cout << "c = " << c << endl;
int d = 30;
int e = demo(a = d);
cout << "c = " << e << endl;
c = 30
c = 32
parámetros de marcador de posición en funciones
En la lista de parámetros formales de una función, podemos establecer un parámetro de marcador de posición para hacer un marcador de posición, pero el marcador de posición debe complementarse al llamar a la función. Los parámetros de marcador de posición también pueden tener parámetros predeterminados.
Sintaxis: valor de retorno tipo función nombre (tipo de datos) {}
Por ejemplo:
int demo03(int a, int)
{
return a;
}
int a = 10;
int b = 20;
int e = demo03(a, b);
cout << "c = " << e << endl;
La salida es:
c = 10
Si una posición ya tiene un parámetro predeterminado, a partir de esta posición, todas las variables en esta posición y a la derecha de esta posición deben tener valores predeterminados.
int demo(int a = 1, int b = 2, int c) //这种语法即为错误使用，此时会报错默认实参不在形参列表的结尾
int demo(int a = 1, int b = 2, int c = 3)//此为正确语法
La declaración e implementación de una función solo puede tener un parámetro predeterminado, no ambos.
int demo01(int a = 1, int b = 2); // 函数的声明
int demo01(int a = 1, int b = 2) //函数的实现。 此时会报错，“demo01”: 重定义默认参数
{
return a + b;
}
sobrecarga de funciones
Hay tres condiciones que deben cumplirse para la sobrecarga de funciones:
1. En el mismo ámbito,
2. El nombre de la función es el mismo,
3. Los parámetros de la función son de diferentes tipos o números o en diferente orden.
Función: el nombre de la función puede ser el mismo, lo que mejora la reutilización.
Tome una castaña de la siguiente manera:
#include<iostream>
using namespace std;
//1、两个example函数都在全局作用域下
//2、两个example函数的名称相同
//3、两个example函数的参数的个数不同
void example()
{
cout << "这是一个例子" << endl;
}
void example(int a)
{
cout << "这是另外一个栗子" << a << endl;
}
int main() {
example();
system("pause");
return 0;
}
la salida es
这是一个例子
Los ámbitos de las dos funciones de ejemplo anteriores están en el ámbito global, lo que satisface la condición 1;
los nombres de función de las dos funciones de ejemplo anteriores son los mismos, lo que satisface la condición 2;
el número de parámetros de las dos funciones de ejemplo anteriores es diferente, que satisface la condición tres;
las tres condiciones se cumplen, por lo que las dos funciones anteriores pertenecen a la sobrecarga de funciones. Cuando llamamos a una función en la función principal, podemos decidir qué función llamar por el número de parámetros de la función o el tipo u orden de los parámetros.
El valor de retorno de la función es diferente y no se puede utilizar como condición para la reutilización de la función.
Por ejemplo:
void example(int a)
{
cout << "这是另外一个栗子" << a << endl;
}
int example(int a)
{
cout << "这是另外一个栗子" << a << endl;
}
Se informará un error en este momento:
无法重载仅按返回类型区分的函数
La razón es que cuando llamamos a las dos funciones anteriores, no podemos distinguir qué función llamar por el valor de retorno. Esto dará un error.
Notas sobre la sobrecarga de funciones
1. Referencia como condición para la sobrecarga de funciones
#include<iostream>
using namespace std;
void example(int &a)
{
cout << "这是一个栗子" << a << endl;
}
void example(const int &a)
{
cout << "const 这是一个栗子" << a << endl;
}
int main() {
//调用第一个函数
int a = 10;
example(a);
//调用第二个函数
example(10);
system("pause");
return 0;
Aquí hay dos funciones que se pueden sobrecargar.Cuando llamamos a la primera función, ingresamos una variable a legible y escribible, pero const restringe la operación de escritura y solo puede leer la variable. Entonces se llama a la primera función; cuando ingresamos una constante, no es un espacio de memoria legal (está en un área constante, no es un área de pila o montón), por lo que no se puede llamar por referencia, ni esta es la razón por la cual la primera función no se puede llamar.Cuando modificamos la referencia por const, el parámetro de la segunda función se convierte en, const int &a = 10. Es decir, se convierte en una referencia constante
, por lo que se llamará a la segunda función.
2. La sobrecarga de la función encuentra el parámetro predeterminado.
Tomemos primero una castaña:
void example01(int a, int b = 1)
{
cout << "const 这是一个栗子" << a << endl;
}
void example01(int a)
{
cout << "const 这是一个栗子" << a << endl;
}
int a = 10;
int b = 20;
example01(a);//此时会报错：有多个 重载函数 "example01" 实例与参数列表匹配
example01(a, b);//这时候就不会报错了
Se informará un error en este momento:
La razón principal es que cuando una función tiene parámetros predeterminados, podemos llamar a esta función sin pasar los parámetros reales de los parámetros predeterminados. Cuando no se pasan argumentos predeterminados, nuestro compilador no sabe a qué función llamar. Podemos resolver este problema especificando el valor del parámetro predeterminado al llamar a esta función sobrecargada.