Use smart pointers with Tensorflow C API objects in a class - c++

Question

I would like to use an object that has specific deleter and constructor in a smart pointer.
The object is called: TF_Status - it is created with the function TF_NewStatus() and delete with the function TF_DeleteStatus().
When I want to use it with a smart pointer, I will initialize it like this:
std::unique_ptr<TF_Status, void(*)(TF_Status*)> status(TF_NewStatus(), TF_DeleteStatus);
However, when I want to use it as a class member, I do not want to create the object in the c'tor, because I have to set some values before. The problem is that there is no default c'tor for this kind of smart pointer.
Do you guys have any solutions?

Answer 1

When I understand correctly, you need something like this:
struct some_t
{
some_t()
: m_status(nullptr, TF_DeleteStatus)
{}
void later()
{
m_status.reset(TF_NewStatus());
}
std::unique_ptr<TF_Status, void(*)(TF_Status*)> m_status;
};
The unique_ptr becomes a zero pointer at construction time. Later you can create the TF_Status object.

Answer 2

You can instantiate a unique_ptr holding a null pointer first, and then reset this pointer with an actual TF_Status:
#include <iostream>
// TF_*
struct TF_Status {};
TF_Status* TF_NewStatus() { std::cout << "\tNew TF_Status\n" ; return new TF_Status(); }
void TF_DeleteStatus(TF_Status* s) { std::cout << "\tDelete TF_Status\n"; delete s; }
#include <memory>
class C
{
std::unique_ptr<TF_Status, decltype(TF_DeleteStatus)*> status;
public:
C() : status(nullptr, TF_DeleteStatus) {}
void acquire_status() {
status.reset(TF_NewStatus());
}
};
// test
int main()
{
std::cout << "About to instantiate a C\n";
C c;
std::cout << "done\n";
std::cout << "About to acquire_status\n";
c.acquire_status();
std::cout << "done\n";
}
Output
g++ -std=c++17 -O2 -Wall -pedantic -pthread main.cpp && ./a.out
About to instantiate a C
done
About to acquire_status
New TF_Status
done
Delete TF_Status
Note that std::unique_ptr::reset :
Given current_ptr, the pointer that was managed by *this, performs the following actions, in this order:
Saves a copy of the current pointer old_ptr = current_ptr
Overwrites the current pointer with the argument current_ptr = ptr
If the old pointer was non-empty, deletes the previously managed object if(old_ptr) get_deleter()(old_ptr).
So you're safe even if your smart pointer contains an actual TF_Status when you invoke reset() on it.
(demo)

Answer 3

I suggest creating a deleter class:
struct TF_Status;
void TF_DeleteStatus(TF_Status*);
struct TF_StatusDeleter {
void operator()(TF_Status* s) noexcept { TF_DeleteStatus(s); }
};
And then:
using TF_StatusPtr = std::unique_ptr<TF_Status, TF_StatusDeleter>;
This way TF_StatusPtr can be default-initialized (no need to explicitly initialize this member in the constructor) and sizeof(TF_StatusPtr) == sizeof(TF_Status*). std::unique_ptr uses empty base-class optimization for the deleter and hence a TF_StatusDeleter sub-object with no data members occupies 0 bytes.
Whereas std::unique_ptr<TF_Status, void(*)(TF_Status*)> is twice as big because each instance stores a pointer to same TF_DeleteStatus function, which is a waste.