W niektórych kontekstach jestem zdezorientowany funkcjami min i max.

W jednym kontekście, gdy używasz funkcji do przyjęcia większej lub mniejszej z dwóch wartości, nie ma problemu. Na przykład,

//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);
}

Łatwo. Ale w innym kontekście jestem zdezorientowany. Jeśli próbuję ustawić maksimum lub minimum, otrzymuję je wstecz.

//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
}

Czy nie jest wskazane, aby tworzyć własne funkcje w następujący sposób?

//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)
}

Oczywiście korzystanie z wbudowanych będzie szybsze, ale wydaje mi się to niepotrzebną mikrooptymalizacją. Czy jest jakiś inny powód, dla którego byłoby to niewskazane? A co z projektem grupowym?

Jak już wspomnieli inni: nie twórz funkcji o nazwie podobnej do wbudowanej biblioteki standardowej lub ogólnie używanej funkcji, ale zmień jej zachowanie. Można przyzwyczaić się do konwencji nazewnictwa, nawet jeśli na pierwszy rzut oka nie ma to większego sensu, ale nie będzie możliwe uzasadnienie działania kodu po wprowadzeniu innych funkcji, które robią to samo, ale mają ich nazwiska zamieniły się.

Zamiast „przeciążać” nazwy używane przez standardową bibliotekę, używaj nowych nazw, które dokładnie odzwierciedlają to, co masz na myśli. W twoim przypadku tak naprawdę nie interesuje Cię „minimum”. Zamiast tego chcesz ograniczyć wartość. Matematycznie jest to ta sama operacja, ale semantycznie nie do końca. Dlaczego więc nie tylko funkcja

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

robi to, co jest potrzebne i mówi to po nazwie. (Można również realizować capw warunkach minjak pokazano w timster „s odpowiedzi ).

Inną często używaną nazwą funkcji jest clamp. Pobiera trzy argumenty i „zaciska” podaną wartość w interwale określonym przez pozostałe dwie wartości.

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;
}

Jeśli używasz tak powszechnie znanej nazwy funkcji, każda nowa osoba dołączająca do Twojego zespołu (w tym przyszłość, którą wrócisz do kodu po chwili) szybko zrozumie, co się dzieje, zamiast przeklinać cię za pomylenie ich przez złamanie ich oczekiwania dotyczące nazw funkcji, które według nich znają.

Jeśli wykonasz taką funkcję, gdzie minimize(4, 10)zwraca 10 , to powiedziałbym, że jest to niewskazane, ponieważ inni programiści mogą cię udusić.

(Okej, może nie dosłownie cię uduszą na śmierć, ale poważnie ... Nie rób tego.)

Aliasowanie funkcji jest w porządku, ale nie próbuj zmieniać znaczenia istniejących terminów

Tworzenie aliasu funkcji jest w porządku - wspólne biblioteki robią to cały czas .

Jednak złym pomysłem jest używanie terminów w sposób sprzeczny z powszechnym użyciem, np. W twoim przykładzie, w którym według ciebie maksymalne i minimalne wartości powinny być odwrócone. Jest to mylące dla innych programistów, a wyrządzicie sobie krzywdę, ucząc się interpretowania tych terminów w niestandardowy sposób.

Więc w twoim przypadku porzuć żargon „minimalny / maksymalny”, który uważasz za mylący, i stwórz własny, łatwy do zrozumienia kod.

Refaktoryzacja Twojego przykładu:

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


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

Jako dodatkowy bonus za każdym razem, gdy spojrzysz na ten kod, będziesz sobie przypominał, w jaki sposób wartości minimalne i maksymalne są używane w języku programowania. W końcu będzie to miało sens w twojej głowie.

Uwielbiam to pytanie. Rozbijmy to jednak.

1: Czy powinieneś zawinąć pojedynczy wiersz kodu?

Tak, mogę wymyślić wiele przykładów, w których możesz to zrobić. Może wymuszasz wpisywanie parametrów lub ukrywasz konkretną implementację za interfejsem. W twoim przykładzie zasadniczo ukrywasz statyczne wywołanie metody.

Dodatkowo w dzisiejszych czasach możesz robić wiele rzeczy w jednym wierszu.

2: Czy nazwy „Min” i „Max” są mylące?

Tak! Oni są całkowicie! Czysty guru kodujący zmieniłby ich nazwy na „FunctionWhichReturnsTheLargestOfItsParameters” lub coś w tym rodzaju. Na szczęście mamy dokumentację i (jeśli masz szczęście) IntelliSense i komentarze, które nam pomogą, aby każdy, kto jest zdezorientowany nazwami, mógł przeczytać o tym, co powinien zrobić.

3: Jeśli sam zmienisz nazwę na coś innego.

Tak, idź po to. Na przykład możesz mieć:

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)
    }
}

Dodaje sens, a osoba dzwoniąca nie musi lub nie chce wiedzieć, jak obliczyć wartość.

4: Jeśli zmienisz nazwę „min” na „maksymalizuj”

Nie!! oszalałeś?! Ale tak, pytanie podkreśla, że ​​różni ludzie odczytują różne znaczenia nazw funkcji i obiektów. To, co jedna osoba uważa za jasne i konwencjonalne, inne jest niejasne i zagmatwane. Dlatego mamy komentarze. Zamiast tego powinieneś napisać:

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

Potem, gdy ktoś czyta

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

wiedzą, że popełniłeś błąd.

Nie . Nie twórz funkcji o nazwach bardzo podobnych do funkcji wbudowanych, ale faktycznie robi to odwrotnie . Może się to wydawać intuicyjne, ale będzie bardzo mylące dla innych programistów, a nawet dla ciebie w przyszłości, gdy będziesz miał więcej doświadczenia.

Znaczenie maxto „maksimum”, ale twoje „intuicyjne” rozumienie przypomina „maksimum”. Ale to po prostu złe zrozumienie funkcji, a zmiana nazwy z maxna maximumnie przekazuje twojej odmiennej interpretacji. Nawet jeśli mocno wierzysz, że projektanci języków popełnili błąd, nie rób czegoś takiego.

Ale zmiana nazwy na tak, cap(x, limit)jak sugerowano, byłaby w porządku, ponieważ wyraźnie przekazuje zamiar, nawet jeśli tylko się zawija min.

To, co może być mylące, to użycie Capped w nazwie funkcji lub zrozumienie, co oznacza wprowadzenie ograniczenia. Jest to ogranicznik i nie wymaga maksimum czegokolwiek.

Jeśli pytasz o najniższą, najmniejszą lub najwcześniejszą, czy uważasz, że Max jest odpowiednią funkcją?

Pozostaw min i maks w spokoju. Napisz testy, aby przynajmniej raz poprawić.

Jeśli musisz tak często korzystać z tych funkcji w swoim projekcie, znajdziesz jakąś wskazówkę, która pomoże ci wyjaśnić, której z nich użyć. Coś w rodzaju <lub>, szeroka część ust jest skierowana w stronę większej wartości.

Aby odpowiedzieć na twoje pytanie: Czy jest jakiś inny powód, dla którego byłoby to niewskazane? A co z projektem grupowym? Ma to sens, że chcesz mieć własne funkcje, co nie stanowi problemu. Upewnij się tylko, że należą do twojej klasy pomocniczej i nie są łatwe do wywołania dla innych, chyba że ją zaimportują. (Joes.Utilities.)

Ale żeby spojrzeć ponownie na twój problem, w zasadzie zamiast tego pomyślałbym:

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

Czujesz się zagubiony, ponieważ próbujesz zastosować logikę mózgu do tych funkcji min / maks. Zamiast tego po prostu mów po angielsku. jest inaczej .ifinputgreater than or equal to 255 then return 255returninput

Który jest:

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

Moja opinia. Idziesz do funkcji max \ min z niewłaściwych powodów, prędkość tych rzeczy jest znikoma. Rób to, co ma sens.

Rozumiem twój problem, ale niechętnie to zrobię. Lepiej po prostu wiercić w czaszce, co robią min () i max ().

Większość programistów wie, co robią funkcje min () i max () - nawet jeśli, podobnie jak ty, czasami zmagają się z intuicją, z której korzystać w danym momencie. Jeśli czytam program i widzę max (x, y), od razu wiem, co on robi. Jeśli utworzysz własną funkcję „alias”, to nikt inny czytający Twój kod nie będzie wiedział, co robi ten alias. Muszą znaleźć twoją funkcję. Niepotrzebnie przerywa przepływ czytania i zmusza czytelnika do dodatkowego myślenia, aby zrozumieć Twój program.

Jeśli masz problem z ustaleniem, którego użyć w pewnym momencie, dodam komentarz wyjaśniający to. Następnie, jeśli przyszły czytelnik jest podobnie zdezorientowany, twój komentarz powinien to wyjaśnić. Lub jeśli zrobisz to źle, ale komentarz wyjaśnia, co próbujesz zrobić, osoba próbująca go debugować będzie miała wskazówkę.

Po aliasowaniu funkcji, ponieważ nazwa koliduje z intuicją ... czy to jedyny przypadek, w którym jest to problem? A może wybierasz alias innych funkcji? Być może jesteś zdezorientowany przez „czytaj” i łatwiej ci myśleć o tym jako o „akceptuj”, zmieniasz „dopisz” na „StringTogether”, „zaokrąglasz” do „DropDecimals” itp. Przenieś to do absurdalnej skrajności a wasze programy będą niezrozumiałe.

Rzeczywiście, lata temu pracowałem z programistą, który nie lubił wszystkich znaków interpunkcyjnych w C. Więc napisał kilka makr, aby pozwolić mu napisać „TO” zamiast „{” i „END-IF” zamiast „}” i dziesiątki innych takich zamian. Więc kiedy próbowałeś czytać jego programy, nie wyglądało to już nawet na C, to było jak nauka nowego języka. Nie pamiętam teraz, czy „AND” przetłumaczone na „&” czy „&&” - i o to chodzi. Podważasz inwestycje, które ludzie włożyli w naukę języka i biblioteki.

To powiedziawszy, nie powiedziałbym, że funkcja, która nie robi nic poza wywołaniem standardowej funkcji bibliotecznej, jest koniecznie zła. Jeśli celem twojej funkcji nie jest tworzenie aliasu, ale zamknięcie zachowania, które akurat jest pojedynczą funkcją, może to być dobre i właściwe. Mam na myśli, że jeśli logicznie i nieuchronnie musisz zrobić maksimum w tym punkcie programu, to po prostu wywołaj maksimum bezpośrednio. Ale jeśli musisz wykonać jakieś obliczenia, które dzisiaj wymagają maksimum, ale które mogą zostać zmodyfikowane w przyszłości, aby zrobić coś innego, odpowiednia jest funkcja pośrednia.

Zmiana nazw wbudowanych funkcji jest w porządku, pod warunkiem, że nowe nazwy znacznie upraszczają kod i nikt go nie zrozumie. (Jeśli używasz C / C ++, nie używaj #define, ponieważ utrudnia to zobaczenie, co się dzieje.) Nazwa funkcji powinna działać jak komentarz wyjaśniający, co robi kod wywołujący i dlaczego .

Nie jesteś jedyną osobą, która miała ten problem z parametrami min i max, jednak wciąż nie widzę dobrego ogólnego rozwiązania, które działa we wszystkich domenach. Myślę, że jednym z problemów związanych z nazywaniem tych funkcji jest to, że dwa argumenty mają różne logiczne znaczenia, ale są przedstawiane w ten sam sposób.

Jeśli Twój język na to pozwala, możesz spróbować

return  calculatedDiscount.ButNoMoreThen(maxAllowedDiscount)

return  CDsInStocked.ButNoMoreThen(CasesInStock)

Nie.

Nie piszesz swoich opakowań. Nazwy tych opakowań nie są bardzo znaczące.

To, co próbujesz zrobić, to miłe zaciemnienie kodu. Wymyślasz dodatkową warstwę, która służy 2 celom:

1. Inne osoby nie mogą zrozumieć Twojego kodu.
2. Nigdy nie uczysz się rozumieć kod innych ludzi.

Ukrywając rzeczy, z którymi nie czujesz się komfortowo, ranisz tylko swój kod teraz i siebie w przyszłości. Nie możesz rosnąć, pozostając w strefie komfortu. Musisz nauczyć się, jak mini maxpracować.

Używanie Min, Max do podkręcania i cofania jest w porządku i nie jest sprzeczne z intuicją. Odbywa się to również przy użyciu:

• floor () i sufit ()
• zacisk, limit, granice
• i oczywiście mod z obcięciem wysokiego rzędu.

W oprogramowaniu sprzętowym sięga dalej niż MMX, który sam wyprzedza nowoczesną grafikę 3D, która opiera się na tym rozszerzeniu.

Zastąpienie funkcji standardowej branży nawet lokalnie martwi mnie, pochodna nazwa może być lepsza. Być może studenci C ++ mogą przeciążać swoją mało znaną klasę.

Jest w porządku, w niektórych przypadkach, ale nie w swoim przykładzie, ponieważ istnieje wiele lepszych sposobów wyrazu to:
saturate, clamp, clip, itd.

Wolałbym stworzyć ogólną funkcję o nazwie „ograniczony”

//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;
}

lub przy użyciu „min” i „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);
}

Co z wywoływaniem funkcji:

atmost(x,255): zwraca niższą z wartości x lub 255 co najwyżej.

atleast(10,x): zwraca wyższą z x lub co najmniej 10.

min(x+y, MAX_VALUE); miałoby znacznie więcej znaczenia niż myCustomFunction(x, y);

Odpowiedź brzmi TAK, jest niewskazana . Służy jedynie jako alias języka twojego mózgu.