Mi confondo sulle funzioni min e max, in determinati contesti.

In un contesto, quando si utilizzano le funzioni per accettare il maggiore o il minore di due valori, non vi è alcun problema. Per esempio,

//how many autographed CD's can I give out?
int howManyAutographs(int CDs, int Cases, int Pens)
{
    //if no pens, then I cannot sign any autographs
    if (Pens == 0)
        return 0;

    //I cannot give away a CD without a case or a case without a CD
    return min(CDs, Cases);
}

Facile. Ma in un altro contesto, mi confondo. Se sto cercando di impostare un massimo o un minimo, lo ottengo indietro.

//return the sum, with a maximum of 255
int cappedSumWRONG(int x, int y)
{
    return max(x + y, 255); //nope, this is wrong
}

//return the sum, with a maximum of 255
int cappedSumCORRECT(int x, int y)
{
    return min(x + y, 255); //much better, but counter-intuitive to my mind
}

È sconsigliabile svolgere le mie funzioni come segue?

//return x, with a maximum of max
int maximize(int x, int max)
{
    return min(x, max);
}

//return x, with a minimum of min
int minimize(int x, int min)
{
    return max(x, min)
}

Ovviamente, usare i builtin sarà più veloce ma a me sembra una inutile microottimizzazione. C'è qualche altro motivo per cui questo sarebbe sconsigliabile? Che dire di un progetto di gruppo?

Come altri hanno già detto: non creare una funzione con un nome simile a quello di una funzione incorporata, standard-library o generalmente usata ma cambiarne il comportamento. È possibile abituarsi a una convenzione di denominazione anche se a prima vista non ha molto senso, ma sarà impossibile ragionare sul funzionamento del codice una volta introdotte quelle altre funzioni che fanno la stessa cosa ma hanno i loro nomi sono stati scambiati.

Invece di "sovraccaricare" i nomi usati dalla libreria standard, usa nuovi nomi che trasmettano esattamente ciò che intendi. Nel tuo caso, non sei veramente interessato a un "minimo". Piuttosto, vuoi limitare un valore. Matematicamente, questa è la stessa operazione ma semanticamente, non è del tutto. Quindi perché non solo una funzione

int cap(int value, int limit) { return (value > limit) ? limit : value; }

fa quello che è necessario e lo dice dal suo nome. (Si potrebbe anche implementare capin termini di mincome mostrato nella timster 's risposta ).

Un altro nome di funzione usato di frequente è clamp. Prende tre argomenti e "blocca" un valore fornito nell'intervallo definito dagli altri due valori.

int clamp(int value, int lower, int upper) {
    assert(lower <= upper);  // precondition check
    if (value < lower) return lower;
    else if (value > upper) return upper;
    else return value;
}

Se stai usando un nome di funzione così generalmente noto, qualsiasi nuova persona che si unisce al tuo team (incluso il futuro che torni al codice dopo un po ') capirà rapidamente cosa sta succedendo invece di maledirti per averli confusi rompendo il loro aspettative sui nomi delle funzioni che pensavano di conoscere.

Se esegui una funzione come quella in cui minimize(4, 10)restituisce 10 , direi che non è consigliabile perché i tuoi colleghi programmatori potrebbero strangolarti.

(Va bene, forse non ti strangoleranno letteralmente a morte, ma sul serio ... Non farlo.)

Alias ​​di una funzione va bene, ma non provare a cambiare il significato dei termini esistenti

È corretto creare un alias della funzione: le librerie comuni lo fanno sempre .

Tuttavia, è una cattiva idea usare i termini in modo contrario all'utilizzo comune, come ad esempio il tuo esempio dove dovrebbero essere capovolti max e min. È fonte di confusione per gli altri programmatori e farai un disservizio allenandoti a continuare a interpretare questi termini in modo non standard.

Quindi, nel tuo caso, abbandona il linguaggio "minimo / massimo" che trovi confuso e crea il tuo codice facile da capire.

Rifattorizzare il tuo esempio:

int apply_upper_bound(int x, int y)
{
    return min(x, y);
}


int apply_lower_bound(int x, int y)
{
    return max(x, y)
}

Come bonus aggiuntivo, ogni volta che guarderai questo codice, ti ricorderai come vengono usati min e max nel tuo linguaggio di programmazione. Alla fine, avrà senso nella tua testa.

Adoro questa domanda. Dividiamolo però.

1: dovresti racchiudere una singola riga di codice?

Sì, posso pensare a molti esempi in cui potresti farlo. Forse stai applicando parametri digitati o stai nascondendo un'implementazione concreta dietro un'interfaccia. Nel tuo esempio stai essenzialmente nascondendo una chiamata al metodo statico.

Inoltre, puoi fare molte cose in una sola riga in questi giorni.

2: I nomi 'Min' e 'Max' sono confusi

Sì! Lo sono totalmente! Un guru del codice pulito li rinominerebbe "FunctionWhichReturnsTheLargestOfItsParameters" o qualcosa del genere. Fortunatamente abbiamo documentazione e (se sei fortunato) IntelliSense e commenti per aiutarci in modo che chiunque sia confuso dai nomi possa leggere su ciò che dovrebbero fare.

3: Dovresti rinominarli in qualcos'altro.

Sì, provaci. Ad esempio, potresti avere:

class Employee
{
    int NumberOfHolidayDaysIShouldHave(int daysInLue, int maxAllowableHolidayDays)
    {
         // Return the number of days in lue, but keep the value under the max allowable holiday days!
         // Don't use max, you fool!!
         return Math.Max(daysInLue, maxAllowableHolidayDays)
    }
}

Aggiunge significato e il chiamante non deve o non vuole sapere come calcolare il valore.

4: Dovresti rinominare "min" per "massimizzare"

No!! sei pazzo?! Ma sì, la domanda sottolinea il fatto che persone diverse leggono significati diversi in nomi di funzioni e oggetti. Ciò che una persona trova chiara e convenzionale un'altra trova opaca e confusa. Ecco perché abbiamo commenti. Dovresti invece scrivere:

// Add x and y, but don't let it go over 255
s = min(x + y, 255);

Quindi quando qualcuno legge

// Add x and y, but don't let it go over 255
s = max(x + y, 255);

sanno che hai fatto un errore.

No . Non creare funzioni con nomi molto simili alle funzioni incorporate, ma che in realtà fa il contrario . Potrebbe sembrare intuitivo per te, ma sarà molto confuso per altri sviluppatori e anche per te stesso in futuro, quando avrai più esperienza.

Il significato di maxè "il massimo di", ma la tua comprensione "intuitiva" è qualcosa come "al massimo di". Ma questa è semplicemente una comprensione errata della funzione e la modifica del nome da maxamaximum non comunica la tua diversa interpretazione. Anche se credi fermamente che i designer linguistici abbiano commesso un errore, non fare qualcosa del genere.

Ma cambiare il nome per dire cap(x, limit)come è stato suggerito andrebbe bene, poiché comunica chiaramente l'intenzione, anche se si chiude min.

Ciò che può confonderti è usare Capped nel nome della tua funzione o la tua comprensione di cosa significhi posizionare un limite. È un limitatore e non richiede un massimo di nulla.

Se ti viene chiesto il più basso, il più piccolo o il primo, pensi che Max sia la funzione appropriata?

Lasciare solo min e max. Scrivi i test in modo che almeno lo otterrai correttamente la seconda volta.

Se ti viene richiesto di utilizzare queste funzioni così tanto nel tuo progetto, ti verrà in mente una sorta di suggerimento che ti aiuterà a chiarire quale utilizzare. In qualche modo simile a <o>, la parte larga della bocca è rivolta verso il valore più grande.

Per rispondere alla tua domanda: c'è qualche altro motivo per cui questo sarebbe sconsigliabile? Che dire di un progetto di gruppo? Ha senso che tu voglia le tue funzioni, il che non è un problema. Assicurati solo che siano nella tua classe di aiuto e non siano facilmente richiamabili per gli altri a meno che non lo importino. (Joes.Utilities.)

Ma per rivedere il tuo problema, in sostanza, invece, penserei:

return (input >= 255) ? 255 : input;

Ti stai confondendo perché stai cercando di applicare la logica del tuo cervello a queste funzioni min / max. Invece parla solo in inglese. ifl' inputè greater than or equal to 255 then return 255altrimenti returnilinput .

Che è:

if (input >= 255) {
   255 
} else {
   input
}

La mia opinione. Stai andando per le funzioni max \ min per ragioni sbagliate, la velocità di queste cose è trascurabile. Fai ciò che ha senso.

Mentre capisco il tuo problema, sarei riluttante a farlo. Sarebbe meglio perforare semplicemente nel tuo cranio cosa fanno min () e max ().

La maggior parte dei programmatori sa cosa fanno le funzioni min () e max () - anche se, come te, a volte lottano con la loro intuizione su quale usare in un dato momento. Se sto leggendo un programma e vedo max (x, y), so immediatamente cosa fa. Se crei la tua funzione "alias", chiunque leggerà il tuo codice non saprà cosa fa questo alias. Devono trovare la tua funzione. Si interrompe inutilmente il flusso di lettura e costringe il lettore a fare qualche pensiero extra per capire il tuo programma.

Se hai difficoltà a capire quale usare ad un certo punto, direi, aggiungi un commento per spiegarlo. Quindi, se un futuro lettore è allo stesso modo confuso, il tuo commento dovrebbe chiarirlo. O se lo fai in modo sbagliato, ma il commento spiega cosa stavi cercando di fare, la persona che cerca di eseguire il debug avrà un indizio.

Una volta che alias una funzione perché il nome si scontra con il tuo intuito ... è l'unico caso in cui questo è un problema? O hai intenzione di alias altre funzioni? Forse sei confuso da "leggi" e trovi più facile pensarlo come "accetta", cambi "append" in "StringTogether", "round" in "DropDecimals", ecc. Ecc. Porta questo ad un estremo ridicolo e i tuoi programmi saranno incomprensibili.

In effetti, anni fa ho lavorato con un programmatore a cui non è piaciuta tutta la punteggiatura in C. Quindi ha scritto un sacco di macro per lasciargli scrivere "THEN" invece di "{" e "END-IF" invece di "}" e dozzine di altre sostituzioni del genere. Quindi, quando hai provato a leggere i suoi programmi, non sembrava nemmeno più C, era come dover imparare una lingua completamente nuova. Non ricordo ora se "AND" tradotto in "&" o "&&" - e questo è il punto. Minerai l'investimento che le persone hanno fatto nell'apprendimento della lingua e della biblioteca.

Detto questo, non direi che una funzione che non fa altro che chiamare una funzione di libreria standard è necessariamente negativa. Se il punto della tua funzione non è creare un alias, ma incapsulare un comportamento che sembra essere una singola funzione, questo potrebbe essere buono e corretto. Voglio dire, se logicamente e inevitabilmente devi fare un max a questo punto nel programma, allora chiama direttamente max. Ma se devi eseguire alcuni calcoli che oggi richiedono un massimo, ma che potrebbero essere modificati in futuro per fare qualcos'altro, allora una funzione intermedia è appropriata.

È OK rinominare le funzioni integrate a condizione che i nuovi nomi rendano il tuo codice molto chiaro e non mancherà a nessuno. (Se stai usando C / C ++ non usare un #define perché rende difficile vedere cosa sta succedendo.) Il nome di una funzione dovrebbe agire come un commento che spiega cosa sta facendo il codice chiamante e perché lo sta facendo .

Non sei l'unica persona che ha avuto questo problema con min e max, tuttavia devo ancora vedere una buona soluzione generale che funzioni in tutti i domini. Penso che un problema con la denominazione di queste funzioni sia che i due argomenti hanno significati logici diversi, ma sono presentati allo stesso modo.

Se la tua lingua lo consente, puoi provare

return  calculatedDiscount.ButNoMoreThen(maxAllowedDiscount)

return  CDsInStocked.ButNoMoreThen(CasesInStock)

No.

Non scrivi i tuoi wrapper. I nomi di questi wrapper non sono molto significativi.

Quello che stai cercando di fare è un tipo di offuscamento del codice. Stai inventando un livello aggiuntivo che ha 2 scopi:

1. Le altre persone non riescono a capire il tuo codice.
2. Non impari mai a capire il codice di altre persone.

Nascondendo cose con cui non ti senti a tuo agio, stai solo danneggiando il tuo codice ora e te stesso in futuro. Non puoi crescere rimanendo nella tua zona di comfort. Ciò di cui hai bisogno è imparare come mine come maxlavorare.

Va bene, e non è affatto controintuitivo usare Min, Max per frenare e sparare. Questo viene fatto anche usando:

• floor () e ceil ()
• morsetto, limite, limiti
• e ovviamente mod con troncamento di alto ordine.

Nel firmware risale oltre MMX, che a sua volta precede la moderna grafica 3D che si basa su questo extensivley.

Sostituire una funzione standard del settore anche a livello locale mi preoccuperebbe, un nome derivato potrebbe essere migliore. Forse gli studenti C ++ potrebbero sovraccaricare la loro classe oscura.

Va bene, in alcuni casi, ma non è nel tuo esempio, perché ci sono modi molto migliori per parola è:
saturate, clamp, clip, etc.

Preferirei creare una funzione generica denominata "limitata"

//Assumes lower_bound <= upper_bound
template <typename T>
T bounded(T value, T lower_bound, T upper_bound){
    if (value < lower_bound)
        return lower_bound;
    if (value > upper_bound)
        return upper_bound;
    return value;
}

//Checks an upper (by default) or lower bound
template <typename T>
T bounded(T value, T bound, bool is_upper_bound = true){
    if (is_upper_bound){
        if (value > bound)
            return bound;
    }
    else {
        if (value < bound)
            return bound;
    }
    return value;
}

o con l'uso di 'min' e 'max'

//Assumes lower_bound <= upper_bound
template <typename T>
T bounded(T value, T lower_bound, T upper_bound){
    return max(min(value, upper_bound), lower_bound);
}

//Checks an upper (by default) or lower bound
template <typename T>
T bounded(T value, T bound, bool is_upper_bound = true){
    if (is_upper_bound)
        return min(value, bound);
    else
        return max(value, bound);
}

Che ne dici di chiamare le tue funzioni:

atmost(x,255): restituisce il minimo di x o 255 al massimo.

atleast(10,x): restituisce il valore più alto di x o almeno 10.

min(x+y, MAX_VALUE); porterebbe molto più significato di myCustomFunction(x, y);

Quindi la risposta è SÌ, non è consigliabile . Serve solo come alias per il tuo linguaggio del cervello.