Otros operadores

Esta página se ha traducido por ordenador/computador/computadora de la versión en inglés de la Wiki usando Google Translate. La traducción puede contener errores y palabras aparatosas/incorrectas. Planea sobre el texto para ver la versión original. Puedes ayudar a corregir los errores y mejorar la traducción. Para instrucciones haz clic aquí.

[editar] Explicación

El operador llamada a función provee semántica de función para cualquier objeto.

El operador condicional (coloquialmente conocido como condicional ternario) comprueba el valor lógico de la primera expresión y, dependiendo del valor resultante, evalúa y devuelve la segunda o tercera expresión.

[editar] Operador de llamada a función integrado

Las expresiones de llamada a función tienen la forma

donde

• E es una expresión que nombra a la función
• A1, A2, A3,... es una lista de expresiones arbitrarias que puede estar vacía, excepto el operador coma no está permitido en el nivel superior para evitar la ambigüedad.

La expresión que da nombre a la función puede ser

El nombre de función (o miembro) especificado por E se puede sobrecargar, las reglas de resolución de sobrecarga se usan para decidir cual de ellas se llama.

Si E especifica una función miembro, podría ser virtual, en cuyo caso se llamará a la sobreescritura final de esa función, usando el manejador dinámico en tiempo de ejecución.

Para llamar a la función,

Cada parámetro de la función se inicializa con su argumento correspondiente después de la conversión implícita si es necesaria. Si no está el argumento correspondiente, se usa el argumento por defecto que corresponde, y si no hay, el programa está mal formado. Si se realiza la llamada a una función miembro, entonces el puntero this al objeto actual se convierte como si fuera conversión explícita al puntero que espera la función. La inicialización y destrucción de cada parámetro ocurre en el contexto del llamador, lo que significa que, por ejemplo, que si el constructor de un parámetro lanza una excepción, el capturador de excepción definido dentro de la función, incluso para un bloque función-try, no se considera. Si la función es una función variable (número variable de argumentos), se aplica las promociones de argumentos por defecto a todos los argumentos coincidentes con el parámetro de puntos suspensivos. La implementación define si el tiempo de vida de un parámetro finaliza cuando la función en el que se define retorna o al final de la expresión completa que lo contiene.

El tipo devuelto por una expresión de llamada a función es el tipo de retorno de la función seleccionada, seleccionado mediante enlace estático (ignorando la palabra reservada virtual), incluso si la función sobrecargada que en realidad se llama devuelve un tipo diferente. Esto permite a las funciones sobrecargadas devolver punteros o referencias a clases que son derivadas del tipo devuelto por la función base, por ejemplo, C++ soporta tipos de retorno covariantes. Si E especifica un destructor, el tipo devuelto es void.

La categoría de valor de una expresión de llamada a función es lvalue si la función devuelve una referencia lvalue o una referencia rvalue a función, es un xvalue si la función devuelve una referencia rvalue a objeto, y es un prvalue en otro caso. Si la expresión de llamada a función es un prvalue de tipo objeto, debe tener tipo completo excepto {rev inl|since=c++17|cuando el prvalue no se materializa, así como}} cuando se usa como operando de decltype (o como el operando derecho de una expresión operador coma integrado esto es el oprando de decltype).

La expresión de llamada a función es similar en sintaxis a una inicialización de valor T(), a una expresión de conversión estilo función T(A1), y a la inicialización directa de un temporal T(A1, A2, A3, ...), donde T es el nombre del tipo.

#include <cstdio>
struct S
{
    int f1(double d) {
        return printf("%f \n", d); // llamada a función de número de argumentos variable
    }
    int f2() {
        return f1(7); // llamada a función miembro, igual que this->f1()
                      // el argumento entero se convierte a double
    }
};
void f() {
   puts("función llamada"); // llamada a función
}
int main()
{
    f(); // llamada a función
    S s;
    s.f2(); // llamada a función miembro
}

función llamada
7.000000

[editar] Operador coma integrado

Las expresiones del operador coma tienen la forma

En una expresión coma E1, E2, se evalúa la expresión E1, su resultado se descarta (aunque si es de tipo clase, no será destruido hasta el final de la expresión completa que la contiene), y sus efectos secundarios se completan antes del comienzo de la evaluación de la expresión E2 (tenga en cuenta que el operator, definido por usuario no puede garantizar la secuencia) (hasta C++17).

El tipo, el valor y la categoría de valor del resultado de la expresión coma son exactamente el tipo, el valor y la categoría de valor del segundo operando, E2. Si E2 es una expresión (desde C++17) temporal, el resultado de la expresión es esa expresión (desde C++17) temporal. Si E2 es un campo de bits, el resultado es un campo de bits.

La coma en varias listas separadas por coma, como el listado de argumentos de una función (f(a, b, c)) y listado de inicialización int a[] = {1,2,3}, no es el operador coma. Si se necesita usar el operador coma en estos contextos, tiene que estar entre paréntesis: f(a, (n++, n+b), c)

#include <iostream>
int main()
{
    int n = 1;
    int m = (++n, std::cout << "n = " << n << '\n', ++n, 2*n);
    std::cout << "m = " << (++m, m) << '\n';
}

n = 2
m = 7

[editar] Operador condicional

Las expresiones del operador condicional tienen la forma

Se evalúa el primer operando del operador condicional y se convierte contextualmente a bool. Después de que completen la evaluación de valor y todos los efectos secundarios del primer operando, si el resultado es true, se evalúa el segundo operando. Si el resultado es false, se evalúa el tercer operando.

El tipo y categoría de valor de la expresión condicional E1 ? E2 : E3 se determina de acuerdo con las siguientes reglas:

std::string str = 2+2==4 ? "ok" : throw std::logic_error("2+2 != 4");

2+2==4 ? throw 123 : throw 456;

struct A {}; 
struct B : A {}; 
using T = const B; 
A a = true ? A() : T(); // Y = A(), TY = A, X = T(), TX = const B. Destino = const A

Para cada par de tipos aritméticos promocionados L y R y para cada tipo P, donde P es un puntero, puntero a miembro, o tipo enumerado con ámbito, los siguientes modelos de función participan en la resolución de sobrecarga realizada en el paso 5 de las reglas anteriores:

Donde LR es el resultado de las conversiones aritméticas usuales realizadas sobre L y R. No se puede sobre cargar el operador “?:”, esos modelos de función solamente existen con el propósito de resolución de sobrecarga.

El tipo de retorno de un operador condicional también es accesible como la característica del tipo binario std::common_type.

#include <string>
#include <iostream>
struct Node
{
    Node* next;
    int data;
    // constructor copia de copia profunda
    Node(const Node& other)
      : next(other.next ? new Node(*other.next) : NULL)
      , data(other.data)
    {}
    Node(int d) : next(NULL), data(d) {}
    ~Node() { delete next ; }
};
int main()
{   
    // ejemplo simple de rvalue 
    int n = 1>2 ? 10 : 11;  // 1>2 es falso, por lo que n = 11
    // ejemplo simple de lvalue
    int m = 10; 
    (n == m ? n : m) = 7; // n == m es falso, entonces m = 7
    std::cout << "n = " << n << "\nm = " << m; // mostrar resultado
}

n = 11
m = 7

[editar] Biblioteca estándar

Muchas clases en la biblioteca estándar sobrecargan el operator() para ser usado como objetos función.

El operador coma no está sobrecargado por ninguna clase en la biblioteca estándar. La biblioteca boost usa operator, en boost.assign, boost.spirit, y otras bibliotecas. La biblioteca de acceso a base de datos SOCI también sobrecarga operator,.

[editar] Informe de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

[editar] Ver también

Precedencia de operadores

Sobrecarga de operadores