Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/memory/unique ptr/get deleter"

From cppreference.com
< cpp‎ | memory‎ | unique ptr
(Added example....)
m (fmt)
 
(12 intermediate revisions by 7 users not shown)
Line 1: Line 1:
 
{{cpp/memory/unique_ptr/title|get_deleter}}
 
{{cpp/memory/unique_ptr/title|get_deleter}}
 
{{cpp/memory/unique_ptr/navbar}}
 
{{cpp/memory/unique_ptr/navbar}}
{{ddcl list begin}}
+
{{dcl begin}}
{{ddcl list item | notes={{mark since c++11}} | 1=
+
{{dcl|since=c++11|notes={{mark|constexpr since C++23}}|1=
     Deleter& get_deleter();
+
Deleter& get_deleter() noexcept;
 
}}
 
}}
{{ddcl list item | notes={{mark since c++11}} | 1=
+
{{dcl|since=c++11|notes={{mark|constexpr since C++23}}|1=
const Deleter& get_deleter() const;
+
const Deleter& get_deleter() const noexcept;
 
}}
 
}}
{{ddcl list end}}
+
{{dcl end}}
  
 
Returns the deleter object which would be used for destruction of the managed object.
 
Returns the deleter object which would be used for destruction of the managed object.
Line 17: Line 17:
 
===Return value===
 
===Return value===
 
The stored deleter object.
 
The stored deleter object.
 
===Exceptions===
 
{{noexcept}}
 
  
 
===Example===
 
===Example===
{{example |
+
{{example
| code=
+
|code=
 
#include <iostream>
 
#include <iostream>
 
#include <memory>
 
#include <memory>
  
struct Foo {
+
struct Foo
     Foo() { std::cout << "Foo...\n"; }
+
{
     ~Foo() { std::cout << "~Foo...\n\n"; }
+
     Foo() { std::cout << "Foo() 0x" << std::hex << (void*)this << '\n'; }
 +
     ~Foo() { std::cout << "~Foo() 0x" << std::hex << (void*)this << '\n'; }
 
};
 
};
 
   
 
   
struct D{
+
struct D
     void bar(){ std::cout << "Call deleter D::bar()...\n";};
+
{
     void operator () (Foo* p) const {
+
    int number;
         std::cout << "Call delete for Foo object...\n";
+
 
 +
     void bar()
 +
    {
 +
        std::cout << "call D::bar(), my number is: " << std::dec << number << '\n';
 +
    }
 +
 
 +
     void operator()(Foo* p) const
 +
    {
 +
         std::cout << "call deleter for Foo object 0x" << std::hex << (void*)p << '\n';
 
         delete p;
 
         delete p;
     };
+
     }
 
};
 
};
  
 
int main()
 
int main()
 
{
 
{
     std::unique_ptr<Foo, D> up(new Foo(), D());
+
    std::cout << "main start\n";
     D& del=up.get_deleter();
+
 
     del.bar();
+
     std::unique_ptr<Foo, D> up1(new Foo(), D(42));
 +
     D& del1 = up1.get_deleter();
 +
     del1.bar();
 +
 
 +
    std::unique_ptr<Foo, D> up2(new Foo(), D(43));
 +
    D& del2 = up2.get_deleter();
 +
    auto* released = up2.release();
 +
    del2(released);
 +
 
 +
    std::cout << "main end\n";
 
}
 
}
| output=
+
|output=
Foo...
+
main start
Call deleter D::bar()...
+
Foo() 0x0x90cc30
Call delete for Foo object...
+
call D::bar(), my number is: 42
~Foo...
+
Foo() 0x0x90cc50
 +
call deleter for Foo object 0x0x90cc50
 +
~Foo() 0x0x90cc50
 +
main end
 +
call deleter for Foo object 0x0x90cc30
 +
~Foo() 0x0x90cc30
 
}}
 
}}
 +
 +
===See also===
 +
{{dsc begin}}
 +
{{dsc inc|cpp/memory/shared_ptr/dsc get_deleter}}
 +
{{dsc end}}
 +
 +
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Latest revision as of 10:43, 10 October 2023

 
 
Utilities library
General utilities
Relational operators (deprecated in C++20)
 
Dynamic memory management
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Allocators
Garbage collection support
(C++11)(until C++23)
(C++11)(until C++23)
(C++11)(until C++23)
(C++11)(until C++23)
(C++11)(until C++23)
(C++11)(until C++23)



 
 
Deleter& get_deleter() noexcept;
(since C++11)
(constexpr since C++23)
const Deleter& get_deleter() const noexcept;
(since C++11)
(constexpr since C++23)

Returns the deleter object which would be used for destruction of the managed object.

Contents

[edit] Parameters

(none)

[edit] Return value

The stored deleter object.

[edit] Example

#include <iostream>
#include <memory>
 
struct Foo
{
    Foo() { std::cout << "Foo() 0x" << std::hex << (void*)this << '\n'; }
    ~Foo() { std::cout << "~Foo() 0x" << std::hex << (void*)this << '\n'; }
};
 
struct D
{
    int number;
 
    void bar()
    {
        std::cout << "call D::bar(), my number is: " << std::dec << number << '\n';
    }
 
    void operator()(Foo* p) const
    {
        std::cout << "call deleter for Foo object 0x" << std::hex << (void*)p << '\n';
        delete p;
    }
};
 
int main()
{
    std::cout << "main start\n";
 
    std::unique_ptr<Foo, D> up1(new Foo(), D(42));
    D& del1 = up1.get_deleter();
    del1.bar();
 
    std::unique_ptr<Foo, D> up2(new Foo(), D(43));
    D& del2 = up2.get_deleter();
    auto* released = up2.release();
    del2(released);
 
    std::cout << "main end\n";
}

Output:

main start
Foo() 0x0x90cc30
call D::bar(), my number is: 42
Foo() 0x0x90cc50
call deleter for Foo object 0x0x90cc50
~Foo() 0x0x90cc50
main end
call deleter for Foo object 0x0x90cc30
~Foo() 0x0x90cc30

[edit] See also

returns the deleter of specified type, if owned
(function template) [edit]