Cant make empty process variable

[thesstraight]

so i have tried doing this using libmem.hpp in c++ 20

libmem::Process process{};

but when compiling with g++ i get error

error: no matching function for call to ‘libmem::Process::Process(<brace-enclosed initializer list>)’
   24 |     libmem::Process process{};

i added Process(){}; before Process(const struct lm_process_t *process);
now i can do this

new code

libmem::Process process{};

    {   
        std::optional<libmem::Process> getProcess{ libmem::FindProcess(::processName.data()) };

        if (!getProcess.has_value())
        {
            std::cerr << "process not found\n";

            return 1;
        }

        process = getProcess.value();
    }

and saves me from doing this

previous code

    std::optional<libmem::Process> getProcess{ libmem::FindProcess(::processName.data()) };

    if (!getProcess.has_value())
    {
        std::cerr << "process not found\n";

        return 1;
    }

    const libmem::Process process(getProcess.value());

what do you think? new code should save some memory if i am correct, is my usage of ur library wrong?
i know i can call getProcess.value() and have 1 variable but calling getProcess.value() on every function that uses libmem::Process can have impact

edit: ill stick to previous code, im not sure if changing the struct may give memory leaks

[rdbo]

You can just do

auto result = libmem::FindProcess(name);
if (!result.has_value()) {
     return 1;
}
libmem::Process process = result.value();

You don't have to use initializer list

[thesstraight]

You can just do

auto result = libmem::FindProcess(name);
if (!result.has_value()) {
return 1;
}
libmem::Process process = result.value();

You don't have to use initializer list

    libmem::Process process(nullptr); // already crashed here

    {   
        auto result = libmem::FindProcess(name);
        if (!result.has_value()) {
            return 1;
        }

        process = result.value();
    }

the issue Process::Process(const struct lm_process_t *process) in cppwrapper.cpp it expects a pointer that is not null, passing a nullptr gives segfault because it derefrences the pointer, this is my guess

Process::Process(const struct lm_process_t *process)
{
	this->pid = process->pid; // if pid or any other member is null it gives segfault
	this->ppid = process->ppid;
	this->arch = static_cast<Arch>(process->arch);
	this->bits = process->bits;
	this->start_time = process->start_time;
	this->path = std::string(process->path);
	this->name = std::string(process->name);
}

there should be either a default constructor like Process(){} or a check against nullptrs to fix this problem is my guess

i will try using new code tomorrow and let you know how it went

currently i use this

    std::optional<libmem::Process> getProcess{ libmem::FindProcess(::processName.data()) };

    if (!getProcess.has_value())
    {
        std::cerr << "process not found\n";

        return 1;
    }

    const libmem::Process process(std::move(getProcess.value()));

    getProcess.reset();

this issue applies to Module struct aswell and probably thread and many more

[rdbo]

Well, there is no such thing as a "default process". Or module, or thread, or any other thing. So there is no default constructor either. You're not supposed to create an empty process, you should always get it from a libmem function.
Is there a use-case for that instead of using the example I gave?

That constructor which receives a const lm_process_t * is also only supposed to be used internally by libmem to convert the C lm_process_t into a C++ Process. You can use it externally if you have a valid lm_process_t - null pointer is not a supported value for it, though.

[thesstraight]

thx for the answer

1st example assign an empty process then use it later or thru out other files

2nd example similiar to 1st one, would just be the code i provided

libmem::Process process{}; // or libmem::Process process;

 { 
const std::optional<libmem::Process> getProcess{ libmem::FindProcess(::processName.data()) }; 

// error checking...

process = getProcess.value();
 } // getProcess is destroyed/freed

[rdbo]

1st I would recommend against it, but if you wanna have a global uninitialized variable used across multiple files, you can use std::unique_ptr or similar.
Example:

std::unique_ptr<lm::Process> my_process = nullptr; // gonna assign later

// ...

var result = libmem::FindProcess(processName);

// error checking
if (!result.has_value()) {
    return 1;
}

my_process = std::make_unique(result.value());

2nd achieves the same result as mine. Mine also has error checking and doesnt need an empty process variable.