Declaring functions

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

Lenguaje C++

Los temas generales

Preprocessor
Comentarios
Palabras clave

Tabla ASCII
Las secuencias de escape
Historia de C++

Control de flujo

Sentencias condicionales ejecución

if statement

switch statement

Instrucciones de iteración

`for` loop
range-`for` loop (C++11)

`while` loop
`do-while` loop

Ir declaraciones

`continue` statement
`break` statement

`goto` statement
`return` statement

Funciones

declaración de la función

lambda declaración de la función

función de plantilla

especificador inline

especificaciones de excepción (obsoleto)

noexcept especificador (C++11)

Excepciones

tirar expresión

bloque try-catch

Los espacios de nombres

espacio de nombres declaración

alias de espacios de nombres

Tipos

tipos fundamentales
tipos de compuestos
los tipos de enumeración

tipos de unión
tipos de funciones

decltype specifier (C++11)

Los especificadores

cv especificadores

almacenamiento duración especificadores

constexpr especificador (C++11)

auto especificador (C++11)

alignas especificador (C++11)

Inicialización

predeterminado de inicialización
valor de inicialización
cero de inicialización
copiar inicialización
inicialización directa

inicialización de agregados
lista de inicialización (C++11)
inicialización constante
referencia de inicialización

Los literales

literales enteros
Los literales de caracteres
Los literales de punto flotante
literales de cadena

Los literales booleanos
nullptr (C++11)
definido por el usuario (C++11)

Expresiones

categorías de valor
orden de evaluación

los operadores
prioridad de los operadores

representaciones alternativas

Utilidades

Tipos

typedef declaration

alias de tipo de declaración (C++11)

atributos (C++11)

Lanza

conversiones implícitas

const_cast conversion

static_cast conversion

dynamic_cast conversion

reinterpret_cast conversion

C-cast estilo y funcional

De asignación de memoria

new expression

delete expression

Clases

clase de declaración
`this` pointer
acceder a los especificadores

amigo especificador
listas de inicializadores

Clase propiedades específicas de la función

función virtual
anular especificador (C++11)
último especificador (C++11)

explícita (C++11)
estático

Funciones especiales miembro

default constructor
copiar constructor
mover constructor (C++11)

copiar asignación
mover asignación (C++11)
destructor

Plantillas

clase de plantilla

función de plantilla

plantilla de especialización

paquetes de parámetros (C++11)

Varios

Montaje en línea

[edit]

Una declaración de función se introduce el nombre de la función y su tipo. Puede aparecer en cualquier ámbito, y que comúnmente se colocan en los archivos de cabecera .


ret `name` `(` params `)` `;`	(1)

ret `name` `(` params `)` cv ref except attr `;`	(2)

`auto` `name` `(` params `)` cv ref except attr `->` ret `;`	(3)	(desde C++11)

Una definición de función proporciona el cuerpo de una función. Sólo puede aparecer en espacio de nombres o ámbito de la clase .


decl `name` `(` params `)` `{` body `}`	(4)

attr decl `name` `(` params `)` cv ref except attr virt `try` init-list `{` body `}` catch	(5)

attr decl `name` `(` params `)` cv ref except attr `->` ret virt `try` init-list `{` body `}` catch	(6)	(desde C++11)

attr decl `name` `(` params `)` cv ref except attr virt `= 0 ;`	(7)

attr decl `name` `(` params `)` cv ref except attr virt `= default ;`	(8)	(desde C++11)

attr decl `name` `(` params `)` cv ref except attr virt `= delete ;`	(9)	(desde C++11)

[editar] Explicación

1)

Declaración de la función típica

2)

Declaración de la función integral

3)

Declaración de la función completa con el tipo de cambio al final

4)

Típico función no miembro definición

5)

Definición de la función integral

6)

Definición de función completa con el tipo de cambio al final

7)

Función miembro virtual pura

8)

Función miembro Fallidos

9)

Suprimido función miembro

attr(C++11)

-

Secuencia opcional de cualquier número de atributos funcionales, tales como [[noreturn]] o [[carries_dependency]]. Puede aparecer tanto antes como después de que el nombre de la función

ret

-

el tipo devuelto por la función, puede ser void si la función no devuelve nada. No puede ser amplia o tipo de función, aunque puede ser un puntero o referencia a los mismos. Se requiere para todas las funciones excepto constructores, destructores y operadores de conversión, que no deben proporcionar un tipo de retorno .

decl

-

declaración secuencia especificador, que consta de ninguno o algunos de los siguientes palabras clave: extern estático,, inline, virtual, explicit, friend, constexpr, combinado con el tipo de retorno, ret

{{par | cv |{{tr| Opcional const, volatile o const volatile, sólo es aplicable a las funciones miembro no estáticas. Para una función miembro de clase T, el tipo de la [[cpp / idioma / este| Optional const, volatile, or const volatile, only applicable to non-static member functions. For a member function of class T, the type of the [[cpp/language/this}}|this pointer]] will be const T*, volatile T*, or const volatile T* respectively. A member function declared const cannot modify members of *this.}}

ref(C++11)

-

Opcional & o &&, sólo es aplicable a las funciones miembro no estáticas que no sean constructores o destructores. Para una función miembro de T clase, el tipo del parámetro objeto implícito el propósito de la resolución de sobrecarga será T& o T&& respectivamente: una función miembro && cualificado sólo se puede llamar en una expresión de objeto rvalue

except

-

ya sea dinámica excepción de especificación o noexcept-especificación

virt(C++11)

-

Opcional override o final, sólo es aplicable a las funciones miembro no estáticas

->ret(C++11)

-

Trailing tipo de retorno, sólo es aplicable si ret es auto. Es útil si el tipo depende de los nombres de argumento, como template <class T, class U> auto add(T t, U u) -> decltype(t + u); o es complicada, como en auto fpif(int)->int(*)(int)

init-list

-

Constructor lista de inicialización, sólo se utiliza en los constructores

try

-

La función opcional de bloque try. Si está presente, catch debe ser proporcionada

catch

-

Secuencia opcional de catch-bloques, sólo aplicable de try se utiliza .

body

-

El cuerpo de la función, una instrucción compuesta (posiblemente vacío)

params

-

La lista de parámetros

[editar] Ejemplo 1: funciones no miembro

#include <iostream>
#include <string>
 
// declaration in namespace(file) scope
// (the definition is provided later)
int f1();
 
// simple function with a default argument, returning nothing
void f0(const std::string& arg = "world") {
    std::cout << "Hello, " << arg << '\n';
}
 
// function returning a pointer to f0
auto fp11() -> void(*)(const std::string&) {
    return f0;
}
 
// function returning a pointer to f0, pre-C++11 style
void (*fp03())(const std::string&) {
    return f0;
}
 
int main()
{
    f0();
    fp11()("test");
    fp03()("again");
    int f2(std::string); // declaration in function scope
    std::cout << f2("bad12") << '\n';
}
 
// simple non-member function returning int
int f1() {
    return 42;
}
 
// function with an exception specification and a function try block
int f2(std::string str) noexcept try { 
    return std::stoi(str);
} catch(const std::exception& e) {
    std::cerr << "stoi() failed!\n";
    return 0;
}

Output:

Hello, world
Hello, test
Hello, again
stoi() failed!
0

[editar] Ejemplo 2: funciones miembro

#include <iostream>
#include <string>
#include <utility>
#include <exception>
 
struct S {
    int data;
 
    // simple converting constructor (declaration)
    S(int val);
 
    // simple explicit constructor (declaration)
    explicit S(std::string str);
 
    // const member function (definition)
    virtual int getData() const { return data; }
 
};
 
// definition of the constructor
S::S(int val) : data(val) {
    std::cout << "ctor1 called, data = " << data << '\n';
}
 
// this constructor has a catch clause
S::S(std::string str) try : data(std::stoi(str)) {
    std::cout << "ctor2 called, data = " << data << '\n';
} catch(const std::exception&) {
    std::cout << "ctor2 failed, string was '" << str << "'\n";
    throw; // ctor's catch clause should always rethrow
}
 
struct D : S {
    int data2;
    // constructor with a default argument
    D(int v1, int v2 = 11) : S(v1), data2(v2) {}
 
    // virtual member function
    int getData() const override { return data*data2; }
 
    // lvalue-only assignment operator
    D& operator=(D other) & {
        std::swap(other.data, data);
        std::swap(other.data2, data2);
        return *this;
    }
};
 
int main()
{
    D d1 = 1;
    S s2("2");
    try {
         S s3("not a number");
    } catch(const std::exception&) {}
    std::cout << s2.getData() << '\n';
 
   D d2(3, 4);
   d2 = d1; // OK: assignment to lvalue
//   D(5) = d1; // ERROR: no suitable overload of operator=
}

Output:

ctor1 called, data = 1
ctor2 called, data = 2
ctor2 failed, string was 'not a number'
2
ctor1 called, data = 3

Lenguaje
Cabeceras
Conceptos
Biblioteca de utilidades
Biblioteca de cadenas
Biblioteca de contenedores
Biblioteca de algoritmos
Biblioteca de iteradores
Biblioteca numérica
Biblioteca de entrada/salida
Biblioteca de localización
Biblioteca de expresiones regulares (C++11)
Biblioteca de operaciones atómicas (C++11)
Biblioteca de tareas/subprocesos (C++11)

cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones

Declaring functions

[editar] Explicación

[editar] Ejemplo 1: funciones no miembro

[editar] Ejemplo 2: funciones miembro

Navegación

Herramientas