Varianti

    std::weak_ptr::owner_before

    Da cppreference.com.

    Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate.

    La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui.

    Click here for the English version of this page

    <metanoindex/>

     
    C++
     
    Utilità libreria
    Tipo di supporto (basic types, RTTI, type traits)
    Gestione della memoria dinamica
    La gestione degli errori
    Programma di utilità
    Funzioni variadic
    Data e ora
    Funzione oggetti
    initializer_list(C++11)
    bitset
    hash(C++11)
    Gli operatori relazionali
    Original:
    Relational operators
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    rel_ops::operator!=
    rel_ops::operator>
    rel_ops::operator<=
    rel_ops::operator>=
    Coppie e tuple
    Original:
    Pairs and tuples
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    pair
    tuple(C++11)
    piecewise_construct_t(C++11)
    piecewise_construct(C++11)
    Swap, in avanti e spostare
    Original:
    Swap, forward and move
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    swap
    forward(C++11)
    move(C++11)
    move_if_noexcept(C++11)
    declval(C++11)
     
    Gestione della memoria dinamica
    Basso livello di gestione della memoria
    Allocatori
    Original:
    Allocators
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    allocator
    allocator_traits(C++11)
    allocator_arg_t(C++11)
    allocator_arg(C++11)
    uses_allocator(C++11)
    scoped_allocator_adaptor(C++11)
    Non inizializzata stoccaggio
    Original:
    Uninitialized storage
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    uninitialized_copy
    uninitialized_copy_n(C++11)
    uninitialized_fill
    uninitialized_fill_n
    raw_storage_iterator
    get_temporary_buffer
    return_temporary_buffer
    Puntatori intelligenti
    Original:
    Smart pointers
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    unique_ptr(C++11)
    shared_ptr(C++11)
    weak_ptr(C++11)
    auto_ptr(deprecato)
    owner_less(C++11)
    enable_shared_from_this(C++11)
    bad_weak_ptr(C++11)
    default_delete(C++11)
    Garbage collection supporto
    Original:
    Garbage collection support
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    declare_reachable(C++11)
    undeclare_reachable(C++11)
    declare_no_pointers(C++11)
    undeclare_no_pointers(C++11)
    pointer_safety(C++11)
    get_pointer_safety(C++11)
    Varie
    Original:
    Miscellaneous
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    pointer_traits(C++11)
    addressof(C++11)
    align(C++11)
    C Library
    Original:
    C Library
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
     
    std::weak_ptr
    Membri funzioni
    Original:
    Member functions
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    weak_ptr::weak_ptr
    weak_ptr::~weak_ptr
    weak_ptr::operator=
    Modificatori
    Original:
    Modifiers
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    weak_ptr::reset
    weak_ptr::swap
    Osservatori
    Original:
    Observers
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    weak_ptr::use_count
    weak_ptr::expired
    weak_ptr::lock
    weak_ptr::owner_before
    Non membri funzioni
    Original:
    Non-member functions
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    std::swap
     
    <tbody> </tbody>
    template< class T > bool owner_before( const weak_ptr<T>& other) const;
    template< class T > bool owner_before( const std::shared_ptr<T>& other) const;
    Controlla se questo weak_ptr precede other in attuazione definito proprietario-based (in alternativa al fair-based) ordine. L'ordine è tale che due puntatori intelligenti confronta equivalente solo se sono entrambi vuoti o se sia proprio lo stesso oggetto, anche se i valori dei puntatori ottenuti get () sono differenti (ad esempio perché puntare sottooggetti diverse all'interno della stessa oggetto)
    Original:
    Checks whether this weak_ptr precedes other in implementation defined owner-based (as opposed to value-based) order. The order is such that two smart pointers compare equivalent only if they are both empty or if they both own the same object, even if the values of the pointers obtained by get() are different (e.g. because they point at different subobjects within the same object)
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Questo ordinamento è usato per fare in comune e puntatori deboli utilizzabili come chiavi in ​​contenitori associativi, di norma nell'ambito std::owner_less.
    Original:
    This ordering is used to make shared and weak pointers usable as keys in associative containers, typically through std::owner_less.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    Parametri

    other -
    il std::shared_ptr o std::weak_ptr da confrontare
    Original:
    the std::shared_ptr or std::weak_ptr to be compared
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    Valore di ritorno

    true se *this precede other, false altrimenti. Implementazioni comuni confrontare gli indirizzi dei blocchi di controllo.
    Original:
    true if *this precedes other, false otherwise. Common implementations compare the addresses of the control blocks.
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    Esempio

    #include <iostream>
#include <memory>
 
struct Foo {
    int n1;
    int n2; 
    Foo(int a, int b) : n1(a), n2(b) {}
};
int main()
{   
    auto p1 = std::make_shared<Foo>(1, 2);
    std::shared_ptr<int> p2(p1, &p1->n1);
    std::shared_ptr<int> p3(p1, &p1->n2);

    std::cout << std::boolalpha
              << "p2 < p3 " << (p2 < p3) << '\n'
              << "p3 < p2 " << (p3 < p2) << '\n'
              << "p2.owner_before(p3) " << p2.owner_before(p3) << '\n'
              << "p3.owner_before(p2) " << p3.owner_before(p2) << '\n';

    std::weak_ptr<int> w2(p2);
    std::weak_ptr<int> w3(p3);
    std::cout 
//              << "w2 < w3 " << (w2 < w3) << '\n'  // won't compile 
//              << "w3 < w2 " << (w3 < w2) << '\n'  // won't compile
              << "w2.owner_before(w3) " << w2.owner_before(w3) << '\n'
              << "w3.owner_before(w2) " << w3.owner_before(w2) << '\n';

}

    Output: 

    p2 < p3 true
p3 < p2 false
p2.owner_before(p3) false
p3.owner_before(p2) false
w2.owner_before(w3) false
w3.owner_before(w2) false

    Vedi anche

    (C++11)
    fornisce di tipo misto proprietario basato su ordinamento di puntatori condivisi e debole
    Original:
    provides mixed-type owner-based ordering of shared and weak pointers
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (classe template) [modifica]