Segmentation Fault(Core dump), Do not know why - c++

Question

I was trying to make up a code that I saw for some distributed application to see its working, but I am getting an error. I am trying to see the working of messages
The code is
class Address {
public:
char addr[6];
Address() {}
Address(string address) {
size_t pos = address.find(":");
int id = stoi(address.substr(0, pos));
short port = (short)stoi(address.substr(pos + 1, address.size()-pos-1));
memcpy(&addr[0], &id, sizeof(int));
memcpy(&addr[4], &port, sizeof(short));
}
};
enum MsgTypes{
JOINREQ,
JOINREPLY,
DUMMYLASTMSGTYPE,
HEARTBEAT
};
/**
* STRUCT NAME: MessageHdr
*
* DESCRIPTION: Header and content of a message
*/
typedef struct MessageHdr {
enum MsgTypes msgType;
}MessageHdr;
typedef struct en_msg {
// Number of bytes after the class
int size;
// Source node
Address from;
// Destination node
Address to;
}en_msg;
void send(Address *myaddr, Address *toaddr, char *data, int size);
int main()
{
MessageHdr *msg;
size_t msgsize = sizeof(MessageHdr) + sizeof(Address) + sizeof(long) + 1;
int id=233;
short port =22;
long heartbeat=1;
string s=to_string(id)+to_string(port);
string s1=to_string(id+1)+to_string(port+1);
Address *addr= new Address(s);
Address *toaddr= new Address(s);
msg->msgType = JOINREQ;
memcpy((char *)(msg+1), addr, sizeof(addr));
memcpy((char *)(msg+1) + 1 + sizeof(addr), (char *)heartbeat, sizeof(long));
send(addr, toaddr, (char *)msg, msgsize);
}
void send(Address *myaddr, Address *toaddr, char *data, int size) {
en_msg *em;
static char temp[2048];
em = (en_msg *)malloc(sizeof(en_msg) + size);
em->size = size;
memcpy(&(em->from), &(myaddr), sizeof(em->from));
memcpy(&(em->to), &(toaddr), sizeof(em->from));
memcpy(em + 1, data, size);
cout<<em;
}
The error is just this line :
Segmentation fault (core dumped)

Answer 1

1) as Retired Ninja said in comments, first line of main must be like
MessageHdr *msg = new MessageHdr();
because msg->msgType = JOINREQ; will cause an error with unassigned msg.
2) the first fix will not help because of expressions like
(char *)(msg+1)
here msg of type MessageHdr * used as char * in address arithmetic. I mean that it is dangerous to calculate addresses by expression of style
(char *)(msg+1) + 1
while msg is of MessageHdr* type, (msg+1) - means a shift to next structure MessageHdr and the additional +1 after casting to char* means shift to one byte. Personally I cannot understand the logic, whereas MessageHdr structure has only one enum field and with so strange address manipulation you are trying to fit instance of Address class (or long int value) to that structure with memcpy.
Conclusion:
Very substantial program redesign is needed with writing comments and using clear logic in operations.