Thread: Create struct on heap

Hi,

I am trying to create struct instance on heap like this:

Code:

class Testhandler
{

    struct TestParms {

    char parm1[48];
    char parm2[sizeof(void *)];
    char parm3[24];
    char parm4[8];
    char parm5[80];

        TestParms(){
        memset(TestParms, 0, sizeof(TestParms));
        };

    };
}

int main
{
    const char * data = buffer.getBuffer();
    MQLONG data = buffer.tell();

    m_TestParms = new (std::nothrow) TestParms();

    memcpy(m_TestParms.parm1, eyeCatcher, sizeof(m_TestParms.parm1));

    memcpy(m_TestParms.parm2, &data, sizeof(m_TestParms.parm2));

    memcpy(m_TestParms.parm3, dataLength, sizeof(m_TestParms.parm3));

    memcpy(m_TestParms.parm4, msgDescriptor.Persistence, sizeof(m_TestParms.parm4));

    memcpy(m_TestParms.parm5, '  ', sizeof(m_TestParms.parm5));
}

msgDescriptor.Persistence has the MQ data type MQBYTE24 and eyeCatcher is const char.

But this is not compiling. What is my mistake?

* moved to C++ programming forum *

Originally Posted by Joe1903

But this is not compiling. What is my mistake?

Your first mistake is not posting the smallest and simplest program that you expect should compile, but which results in a particular compile error. Your second mistake is not posting the compile error.

Besides these, one obvious mistake is that you wrapped the TestParms struct in a class, but nowhere do you ever use that class.

Yet another mistake is that you used m_TestParms without declaring it... but because of your first two mistakes, it is impossible to tell if this is a mistake or merely some abbreviated code. Related to this: because you chose to use nothrow new, you must check that the pointer is not a null pointer before using it. I suggest not using nothrow new unless you really must. Oh, and then you must delete what you new... but post-C++11, we would use a std::unique_ptr<TestParms> with std::make_unique instead of directly using new and delete.

No. If I were you, I would start with something simpler, e.g.,

Code:

#include <memory>
#include <string>
#include <cstring>
#include <iostream>

struct TestParms
{
    char parm1[48];
    char parm2[sizeof(void *)];
    char parm3[24];
    char parm4[8];
    char parm5[80];
};

int main()
{
    auto testParms = std::make_unique<TestParms>();
    std::string input{"hello"};
    std::memcpy(testParms->parm1, &input[0], input.length());
    std::cout << testParms->parm1 << std::endl;
    std::cout << static_cast<int>(testParms->parm5[10]) << std::endl;
}

Now, std::make_unique performs value initialisation, which means that the member arrays will be zero initialised. If you prefer, you could still provide a constructor, but your use of memcpy in the constructor is wrong: it may be simpler to just use the initialiser list.

Once you get this to work, you can then add in the memcpy calls for the various member arrays. Once you get that to work, you can then add the class wrapper: the thing that you're missing is a declaration of m_TestParms as a member of the class. (Also pay attention to private versus public member access.)

Yes, but then you won't meet your "create struct instance on heap" requirement.

The second is probably better: you can just take the address of the local variable at the end. No need to worry about unique_ptr and even think about memory management.

Originally Posted by laserlight

The second is probably better: you can just take the address of the local variable at the end. No need to worry about unique_ptr and even think about memory management.

I thought something like this:

TestParms * testParmsPtr = &myStruct;

Last question: For my second try, would my constructor set all parms to 0 (memset)? Is this correct how I did it?
And do you know anything about MQ data types? I am not sure whether this would work:

memcpy(myStruct.parm4, dataLength, sizeof(myStruct.parm4)); as the data type of dataLength is MQLONG (32-bit integer) and parm4 is char[8].