C ++ Std właściciel mniej

W tym artykule będziemy omawiać obiekt funkcyjny w języku C ++, STD :: właściciela_less. Jego pełna forma jest właściciela mniej niż operacja. Aby to szczegółowo wyjaśnić, musisz najpierw zrozumieć, jakie są obiekty funkcyjne. Obiekty funkcyjne są również znane jako Functors w C++. Functors są jak bloki konstrukcyjne do komponowania większych programów. Najważniejsze, co robimy w Functors, jest to, że konstruujemy obiekty z funkcji. Tak więc w tym przypadku robimy obiekt jako funkcję.

Functor to funkcja o stanie, a kluczem do utrzymania tego stanu jest operator (). Functor to funkcja osiągana poprzez przeciążenie operatora słów kluczowych () w niektórych klasach. Tak więc Functors to obiekty, które działają jak funkcje. Ta sama stara funkcja składniowa jest używana do wywoływania funtów. Functor jest konstruowany przez utworzenie obiektu, który przeładowuje operator. Omówmy teraz Functor właściciela_. Ten obiekt FUNCTOR lub Funkcja, zamiast zamawiania typów opartych na wartości, zapewnia nam zamieszanie typów mieszanych opartych na właścicielach zarówno STD :: słabe_ptr i std :: shared_ptr.

Zostało mu zamówione w taki sposób, że te dwa inteligentne wskaźniki dopasowują się tylko wtedy, gdy oboje dzielą własność. Lub jeśli oba są puste, nawet jeśli uzyskaliśmy wartości z metod Gettera surowych wskaźników, nie są takie same. Wykonują one porównania opartych na właścicielach między słabych wskaźników i wspólnych wskaźników. „Właściciel_less” służy do zamawiania adresu bloku sterowania. Tak więc rozważa dwa słabe wskaźniki lub wspólne wskaźniki równoważne, jeśli podzielają tę samą własność.

Składnia:

Składnia dla właściciela mniej operatora to:

szablon struct właściciel_less;
niczyj>

Standardowa biblioteka C ++ daje nam specjalizację STD :: właściciela_less, gdy „t” nie jest inicjowane. W przypadku tego parametry są odejmowane z listy parametrów.

Zauważ, że jest to szablon dla właściciela_less. Nie ma specyficznej składni, ponieważ jest to podejście do rozwiązania problemu za pomocą inteligentnych wskazówek i functorów.

Członkowie właściciela_less

Bool Operator () (const std :: shared_ptrI LHS,
const std :: shared_ptri RHS) const no -except

Przykład nr 01:

W tym celu nie napisaliśmy żadnego złożonego kodu, który wykorzystuje jakąkolwiek strukturę, klasę, funkcję ani żadnego obiektu programowania takiego jak te. Zamiast tego próbowaliśmy napisać kod, który może być tak prosty, jak to możliwe bezpośrednio w naszej głównej metodzie. Zainicjowaliśmy wskaźnik całkowitej liczby danych o długości 10.

Następnie ogłosiliśmy wspólny wskaźnik „X” o długości 20. Oświadczyliśmy kolejny współdzielony wskaźnik o długości jako wspólny wskaźnik „x”. W następnym wierszu ustawiliśmy wskaźnik na oparte na wartościach. W wierszu 12 ustawiliśmy nasze wskaźniki na wskaźniki bez właściciela. Teraz wykonamy wstawki oparte na wartościach dla naszych wskaźników X i Y.

Następnie zrobimy to samo, ale właściciela oparte na naszych wskaźnikach X i Y, korzystając z naszego Functor Std :: właściciela_less. Należy pamiętać, że napisaliśmy ten sam kod zarówno dla wskazówek opartych na wartości, jak i właściciela. Jedyną różnicą jest to, że używamy słowa kluczowego STD :: właściciela.

Teraz, aby pokazać różnicę wartości i różnicę wielkości między tymi dwoma podejściami, wydrukowaliśmy rozmiar wskaźników opartych na wartościach i właściciela. Następnie, w wierszu nr 20, usunęliśmy wskaźnik, który początkowo stworzyliśmy na początku naszej głównej funkcji. W ostatnim wierszu zwróciliśmy 0, ponieważ typem naszej głównej metody to liczba całkowita. Więc zwróciliśmy 0. Teraz wykonamy nasz kod i sprawdzimy nasz wynik.

#włączać
#włączać
#włączać
int main ()

int * pointer = new int (10);
std :: shared_ptr X (nowy int (20));
std :: shared_ptr y (x, wskaźnik);
STD :: zestaw < std::shared_ptr > value_based;
STD :: zestaw < std::shared_ptr, STD :: właściciel_less>> właściciel_based;
value_bed.wstaw (x);
value_bed.wstaw (y);
właściciel_bany.wstaw (x);
właściciel_bany.wstaw (y);
STD :: Cout << "value_based.size() is " << value_based.size() << '\n';
STD :: Cout << "owner_based.size() is " << owner_based.size() << '\n';
Usuń wskaźnik;
powrót 0;

Dane wyjściowe, które otrzymujemy z powyższego wykonanego kodu, jest następujące. Jeśli spojrzymy na wyjście, zobaczymy, że rozmiar wskaźnika opartego na wartości wynosi 2, a rozmiar wskaźnika opartego na właścicielu wynosi 1. Powstaje pytanie, że jeśli wykonaliśmy te same kroki dla obu z nich, to dlaczego ich rozmiary są różne? Odpowiedź brzmi, że, jak omówiliśmy wcześniej we wstępie, ten FUNCTOR zapewnia zamówienie typów opartych na właściciela, a dwa wskazówki porównują równoważnie, jeśli mają one ten sam własność. Ale jeśli wartości są różne dla obu wskaźników, to dlaczego dzielą tę samą własność?

Jest to więc główna zaleta obiektu funkcji bez właściciela, nawet jeśli wartości są różne i nie są równe, dzielą tę samą własność. Właśnie dlatego wielkość opartej na wartości jest dwa, ponieważ ma dwa wskaźniki i oba mają inną własność. Ale w oparciu o właściciela używamy Functors bez właściciela, który jest spowodowany udostępnianiem tej samej własności, rozmiar to jeden. W naszym przypadku, ponieważ dwa wspólne wskaźniki dzielą tę samą własność, dlatego są uważane za równoważne, a wielkość bazy właściciela staje się 1.

Wniosek

W tym przewodniku omówiliśmy rodzaj obiektu funkcji w C ++, który jest std :: właścicielem. Wyjaśniliśmy o obiektach funkcyjnych, w jaki sposób te obiekty są używane i jak są one zadeklarowane i wywoływane. Następnie omówiliśmy STD :: właściciele_less funkcja i wyjaśniliśmy ich aplikacje i definicję w kategoriach programowania. Później wyjaśniliśmy ich składnię i spojrzeliśmy na ich członków. Wykonaliśmy również praktyczny przykład tego tematu, abyś mógł zrozumieć tę koncepcję bardziej szczegółowo. Podsumowując ten temat, możemy powiedzieć, że std :: właściciele_less definiuje funkcje lub obiekty funkcyjne, które dokonują porównań opartych na właścicielach między słabymi wskaźnikami i wspólnymi wskaźnikami.