c++ - que - php operador logico or

¿Qué es el operador “<?=” En C++?

Question

Esta pregunta ya tiene una respuesta aquí:

• Extensión C: <? y>? operadores 2 respuestas

Encontré el siguiente código here , que es de la implementación C ++ del algoritmo Dijkstra usando una matriz de adyacencia.

//read in edges keeping only the minimum
for(int i=0; i<E; i++) {
int v1,v2,tmp;
fin >> v1; fin >> v2;
fin >> tmp;
adjmat[v1][v2]<?=tmp; // <?= sets left to min(left,right)
adjmat[v2][v1]<?=tmp;
}

Preste atención a las dos últimas líneas, que aplican el operador <?= . Como se comentó, la siguiente línea

adjmat[v1][v2]<?=tmp; // <?= sets left to min(left,right)

se establecerá de left a min(left,right) .

Nunca he visto a este operador antes. Probé el código en VS, no puedo compilar. ¿Qué es? ¿Cómo se puede establecer que la left sea min(left,right) ?

Answer 1

Es equivalente a:

adjmat[v1][v2] = (adjmat[v1][v2]<tmp)? adjmat[v1][v2] : tmp;

En general:

a OP ?= b; <=> a = (a OP b)? a : b; a = (a OP b)? a : b;

Un pequeño ejemplo (compilado con MingW2.95 y C-Free IDE en Windows) que muestra lo que @Kerrek SB dijo: la extensión GCC evalúa los operandos solo una vez, lo cual es bueno

#include <stdio.h>
int f(int x)
{
printf ("Calling f() with x=%d/n", x);
return x*x;
}
int main()
{
int a,b,c;
printf ("A and B? ");
scanf ("%d%d", &a, &b);
c = a;
a = (a<f(b))? a : f(b);
printf ("A using ternary operator: %d/n", a);
a = c;
a <?= f(b);
printf ("A using weird GCC extension: %d/n", a);
return 0;
}
A and B? 3 1
Calling f() with x=1
Calling f() with x=1
A using ternary operator: 1
Calling f() with x=1
A using weird GCC extension: 1

Answer 2

Es una antigua extensión de GCC ; hace lo que dice en el comentario (es la forma de asignación compuesta del operador "mínimo"). Esto no es estándar de C ++.

La diferencia entre a = a < b ? a : b a = a < b ? a : b y a <?= b es que este último solo evalúa cada operando una vez.

En el estándar moderno de C ++, creo que podría escribir un algoritmo de "asignar el mínimo" como este:

auto && __a = a;
auto && __b = b;
if (!(__a < __b)) { __a = std::forward<decltype(__b)>(__b); }

Este debe ser el cuerpo de una macro que tiene el efecto de a <?= b , y a y b son expresiones arbitrarias, potencialmente con efectos secundarios. O podrías envolverlo en una plantilla:

template <typename T,
typename U,
typename P = std::less<std::common_type_t<std::decay_t<T>, std::decay_t<U>>>
T && clamp_to_minimum(T && a, U && b, P p = P())
{
if (!(p(a, b))) { a = std::forward<U>(b); }
return std::forward<T>(a);
}