Un min = idioma in C++?

Question

Usiamo

x += y 

invece di

x = x + y 

E allo stesso modo per *,/,- e altri operatori. Beh, che dire

x min= y 

invece di

x = std::min(x, y) 

? Esiste un idioma comunemente usato per questo comando, che non richiede l'estensione (impossibile) della lingua con un altro operatore?

Answer 1

E 'certamente non idiomatica , ma potresti essere in grado di utilizzare qualcosa chiamato con nome operatori (vedere questi Q & Come here e here, sviluppato da @Yakk e @KonradRudolph), e scrivere

x <min>= y; 

che è reso possibile da sovraccarico operator< e operator>, combinato con un intelligente avvolto named_operator. Il codice completo è dato dal link qui sopra, ma usa il codice come

template <typename T1, typename T2, typename F> 
inline auto operator >(named_operator_lhs<T1, F> const& lhs, T2 const& rhs) 
    -> decltype(lhs.f(std::declval<T1>(), std::declval<T2>())) 
{ 
    return lhs.f(lhs.value, rhs); 
} 

Utilizzando come modello std::min argomento per il parametro modello F, sarebbe aggiornare i LHS dell'espressione con il minimo dei sx e dx.

Answer 2

Non è possibile scrivere questo tipo di frasi, che sono riservati per il built-in syntaxt

Answer 3

NO. Non v'è nulla di simile, avrete a che fare con std::min(x,y);

Answer 4

Le opzioni che si hanno:

x = std::min(x,y) 

o

x = y < x ? y : x; 

o

if (y < x) x = y; 

Answer 5

No, non è possibile creare nuovi operatori personalizzati.

avete un paio di soluzioni a disposizione però:

llama_min_age = std::min(x, y); 
llama_min_age = (x < y ? x : y); 

O anche una macro se si desidera:

#define MIN(x, y) ((x) < (y) ? (x) : (y)) 

Circa la macro: si può portare a bug vizioso, quindi io preferirei utilizzare una delle prime due soluzioni.

Answer 6

Non è possibile estendere la lingua in questo modo.Il più vicino si può venire è qualcosa di simile:

template <typename T, typename U> 
T& 
mineq(T& lhs, U rhs) 
{ 
    if (rhs < lhs) { 
     lhs = rhs; 
    } 
    return lhs; 
} 

Ciò consentirebbe di scrittura:

mineq(x, y); 

mi chiedo se vale la pena il fastidio, però.

Answer 7

C++ ha un numero limitato di operators e keywords.

Quello che stai cercando di fare è al di fuori delle specifiche C++ e non è possibile.

Si può fare il confronto e l'assegnazione a questo one-liner, se si desidera:

x = (x < y) ? x : y;