casting error struct to void * in template

I'm developing a template library for IPC in my application using Boost.Interprocess as base dependency.<br>
I'm getting the bellow mentioned error.<br>
I intend to mainly struct (by type punning) and some-times classes (by binary serialization).<br>

I'm passing const reference as a parameter.<br>
I tried removing const specifier using const_cast type conversion before converting it to

Error

1>C:\Users\admin\source\repos\TestApplication\TestApplication\Ipc.h(49,1): error C2440: 'reinterpret_cast': cannot convert from 'T' to 'void *'
1>C:\Users\admin\source\repos\TestApplication\TestApplication\Ipc.h(53,1): error C2440: 'reinterpret_cast': cannot convert from 'const T' to 'void *'

Code

template <typename T> class Ipc { 
public:
 	bool send(const T& buffer, std::uint32_t priority = 0);  	

    Ipc(const std::string& queue_name, bool communication_module = false, int message_max_number = 5) :  		mq_com_receive(boost::interprocess::open_or_create, (queue_name + "_receive").c_str(), message_max_number, sizeof(T)),  			mq_com_send(boost::interprocess::open_or_create, (queue_name + "_send").c_str(), message_max_number, sizeof(T)),
        				communication_module(communication_module) {}

private: 	
boost::interprocess::message_queue mq_com_receive; 	 
boost::interprocess::message_queue mq_com_send; 	
bool communication_module; };

template<typename T>
inline bool Ipc<T>::send(const T& buffer, std::uint32_t priority)
{
    bool communication_module  = true;
	try
	{
		if (communication_module == true)
		{
			return this->mq_com_send.try_send(reinterpret_cast<void*>(const_cast<T>(buffer)), sizeof(buffer), priority);
		}
		else
		{
			return this->mq_com_receive.try_send(reinterpret_cast<void*>(buffer), sizeof(buffer), priority);
		}
		
	}
	catch(const std::exception& ex)
	{
		//TODO Log Exception
		return false;
	}
}

main.cpp

typedef struct
{
	std::uint8_t id;
	std::string ip;
}sensor_data_t;


int main()
{
    sensor_data_t data;
    data.id = 1;
    data.ip = "192.168.1.101";
    Ipc<sensor_data_t> i{ "test" };
    i.send(data);
}

Your send function is declared as such:

template<typename T>
inline bool Ipc<T>::send(const T& buffer, std::uint32_t priority)

The buffer parameter here is of type T. However, there is no guarantee that T is a pointer.

And indeed, in your main:

int main()
{
    sensor_data_t data;
    data.id = 1;
    data.ip = "192.168.1.101";
    Ipc<sensor_data_t> i{ "test" };
    i.send(data);
}

data here is of type sensor_data_t, which is a value type, not a pointer.

Therefore, when you reinterpret_cast<void*>(buffer), you essentially try to cast a value to a pointer, which is not possible.

To get the pointer of a value, you can use the & (address-of) operator to get the pointer to your buffer here.

Here's a revised version of your code:

template<typename T>
inline bool Ipc<T>::send(const T& buffer, std::uint32_t priority)
{
    bool communication_module = true;
    try
    {
        if (communication_module)
        {
            return this->mq_com_send.try_send(reinterpret_cast<void*>(&const_cast<T&>(buffer)), sizeof(buffer), priority);
        }
        else
        {
            return this->mq_com_receive.try_send(reinterpret_cast<void*>(&const_cast<T&>(buffer)), sizeof(buffer), priority);
        }
        
    }
    catch (const std::exception& ex)
    {
        // TODO Log Exception
        return false;
    }
}

This way, you get the pointer to the buffer passed in parameter, and cast it to void*, which should work assuming that the functions you didn't send the content of are correct.

One last thing, make sure that the function called by this->mq_com_send.try_send actually copies the content of the buffer to send and sends them before the function returns rather than just copying the buffer's pointer for later send or whatnot, as your buffer will get out of scope as soon as your main function returns.

Edit

> Can you elaborate on your last paragraph?

You declared sensor_data_t data; in your main function, in which you called i.send(T& buffer) by passing data to it by reference.

Since sensor_data_t data; has been created in your main function, it exists for as long as your main function does not return, because it'll get out of scope (data is on the stack).

We don't know the details of implementation of mq_com_send.try_send though.
So it is possible that it does not send the content of your buffer immediately, nor copies its content for a later send.

Some network libraries save the pointer to the buffer in a queue, to then send its content asynchronously, in another thread than the one you called your try_send function in (with a potential callback after the data has been sent for you to free it or whatever).

Which means that if this is the case, then it is possible that the buffer is sent after main returns, which can be the source of an error because said buffer will have been invalidated by that time.

So, you should make sure that your try_send function does not do this and in fact either sends the content of your buffer immediately, or queues a copy of the buffer that is handled separately.