상속에서 발생하는 생성자 정의 시 오류 질문이요.

#include "Common.h"
 
class CPacketHeader
{
public:
	CPacketHeader();
	virtual ~CPacketHeader();
 
	virtual void CShowPacket() {};
	virtual void CPacketConversion(char *) {};
	virtual void CSendPacket(int ) {};
};
 
 
class CLoginAuthReqPacket : public CPacketHeader
{
public:
	CLoginAuthReqPacket();
	~CLoginAuthReqPacket();
 
	virtual void CShowPacket();
	virtual void CPacketConversion(char *);
	virtual void CSendPacket(int );
private:
	dgt_auth_req_msg m_auth_req_msg;
};
 
class CLoginAuthResPacket : public CPacketHeader
{
public:
	CLoginAuthResPacket();
	~CLoginAuthResPacket();
 
	virtual void CShowPacket();
	virtual void CPacketConversion(char *);
	virtual void CSendPacket(int );
private:
	dgt_auth_res_msg m_auth_res_msg;
 
};
 
class CSqlReqPacket : public CPacketHeader
{
public:
	CSqlReqPacket();
	~CSqlReqPacket();
 
	virtual void CShowPacket();
	virtual void CPacketConversion(char *);
	virtual void CSendPacket(int );
private:
	dgt_sql_req_msg m_sql_req_msg;
};
 
class CSqlResPacket : public CPacketHeader
{
public:
	CSqlResPacket();
	~CSqlResPacket();
 
	virtual void CShowPacket();
	virtual void CPacketConversion(char *);
	virtual void CSendPacket(int );
private:
	dgt_sql_res_msg m_sql_res_msg;
};
 
class CCloseReqPacket : public CPacketHeader
{
public:
	CCloseReqPacket();
	~CCloseReqPacket();
 
	virtual void CShowPacket();
	virtual void CPacketConversion(char *);
	virtual void CSendPacket(int );
private:
	dgt_close_req_msg m_close_req_msg;
};
 
class CCloseResPacket : public CPacketHeader
{
public:
	CCloseResPacket();
	~CCloseResPacket();
 
	virtual void CShowPacket();
	virtual void CPacketConversion(char *);
	virtual void CSendPacket(int );
private:
	dgt_close_res_msg m_close_res_msg;
};

CPacketHeader::CPacketHeader()
{
 
}
 
CPacketHeader::~CPacketHeader()
{
 
}
 
// 생성자
CLoginAuthReqPacket::CLoginAuthReqPacket()
{
	bzero(&m_auth_req_msg, 0);
}
// 소멸자
CLoginAuthReqPacket::~CLoginAuthReqPacket()
{
 
}
// 생성자
CLoginAuthResPacket::CLoginAuthResPacket()
{
	bzero(&m_auth_res_msg, 0);
}
// 소멸자
CLoginAuthResPacket::~CLoginAuthResPacket()
{
 
}
// 생성자
CSqlReqPacket::CSqlReqPacket()
{
	bzero(&m_sql_req_msg, 0);
}
// 소멸자
CSqlResPacket::~CSqlResPacket()
{
 
}
// 생성자
CCloseReqPacket::CCloseReqPacket()
{
	bzero(&m_close_req_msg, 0);
}
// 소멸자
CCloseResPacket::~CCloseResPacket()
{
 
}
 
// 로그인 요청 패킷 보여주기
void CLoginAuthReqPacket::CShowPacket()
{
	cout << "[LOGIN AUTH REQ PACKET]" << endl;
	cout << "[MSG TYPE] : " << m_auth_req_msg.msg_type << endl;
	cout << "[DB USER] : " << m_auth_req_msg.db_user << endl;
	cout << "[PASSWORD] : " << m_auth_req_msg.password << endl;
	cout << "[PROGRAM NAME] : " << m_auth_req_msg.program_name << endl;
	cout << "[DB NAME] : " << m_auth_req_msg.db_name << endl;
}
 
// 로그인 응답 패킷 보여주기
void CLoginAuthResPacket::CShowPacket()
{
	cout << "[LOGIN AUTH RES PACKET]" << endl;
	cout << "[MSG TYPE] : " << m_auth_res_msg.msg_type << endl;
	cout << "[LOGIN RES MSG]" << endl;
	cout << m_auth_res_msg.rtn_msg << endl;
};
 
// sql 요청 패킷 보여주기
void CSqlReqPacket::CShowPacket()
{
	cout << "[SQL REQ PACKET]" << endl;
	cout << "[MSG TYPE] : " << m_sql_req_msg.msg_type << endl;
	cout << "[SQL TYPE] : " << m_sql_req_msg.sql_type << endl;
	cout << "[SQL TEXT] : " << m_sql_req_msg.sql_text << endl;
};
 
// sql 응답 패킷 보여주기
void CSqlResPacket::CShowPacket()
{
	cout << "[SQL RES PACKET]" << endl;
	cout << "[MSG TYPE] : " << m_sql_res_msg.msg_type << endl;
	cout << "[SQL TYPE] : " << m_sql_res_msg.sql_type << endl;
	cout << "[SQL RES MSG] "<< endl;
	cout << m_sql_res_msg.rtn_data << endl;
};
 
// 종료 요청 패킷 보여주기
void CCloseReqPacket::CShowPacket()
{
	cout << "[CLOSE REQ PACKET]" << endl;
	cout << "[MSG TYPE] : " << m_close_req_msg.msg_type << endl;
};
 
// 종료 응답 패킷 보여주기
void CCloseResPacket::CShowPacket()
{
	cout << "[CLOSE RES PACKET]" << endl;
	cout << "[MSG TYPE] : " << m_close_res_msg.msg_type << endl;
	cout << "[CLOSE RES MSG] " << endl;
	cout << m_close_res_msg.rtn_msg << endl;
}
 
// 로그인 요청 패킷 변환
void CLoginAuthReqPacket::CPacketConversion(char * a_chpBuf)
{
	memcpy(&m_auth_req_msg, a_chpBuf, sizeof(dgt_auth_req_msg));
}
 
// 로그인 응답 패킷 변환
void CLoginAuthResPacket::CPacketConversion(char * a_chpBuf)
{
	memcpy(&m_auth_res_msg, a_chpBuf, sizeof(dgt_auth_res_msg));
}
 
// sql 요청 패킷 변환
void CSqlReqPacket::CPacketConversion(char * a_chpBuf)
{
	memcpy(&m_sql_req_msg, a_chpBuf, sizeof(dgt_sql_req_msg));
}
 
// sql 응답 패킷 변환
void CSqlResPacket::CPacketConversion(char * a_chpBuf)
{
	memcpy(&m_sql_res_msg, a_chpBuf, sizeof(dgt_sql_res_msg));
}
 
// 종료 요청 패킷 변환
void CCloseReqPacket::CPacketConversion(char * a_chpBuf)
{
	memcpy(&m_close_req_msg, a_chpBuf, sizeof(dgt_close_req_msg));
}
 
// 종료 응답 패킷 변환
void CCloseResPacket::CPacketConversion(char * a_chpBuf)
{
	memcpy(&m_close_res_msg, a_chpBuf, sizeof(dgt_close_res_msg));
}
 
// 로그인 요청 패킷 전송
void CLoginAuthReqPacket::CSendPacket(int a_sock)
{
	send(a_sock, &m_auth_req_msg, sizeof(dgt_auth_req_msg), 0);
}
 
// 로그인 응답 패킷 전송
void CLoginAuthResPacket::CSendPacket(int a_sock)
{
	send(a_sock, &m_auth_res_msg, sizeof(dgt_auth_res_msg), 0);
}
 
// sql 요청 패킷 전송
void CSqlReqPacket::CSendPacket(int a_sock)
{
	send(a_sock, &m_sql_req_msg, sizeof(dgt_sql_req_msg), 0);
}
 
// sql 응답 패킷 전송
void CSqlResPacket::CSendPacket(int a_sock)
{
	send(a_sock, &m_sql_res_msg, sizeof(dgt_sql_res_msg), 0);
}
 
// 종료 요청 패킷 전송
void CCloseReqPacket::CSendPacket(int a_sock)
{
	send(a_sock, &m_close_req_msg, sizeof(dgt_close_req_msg), 0);
}
 
// 종료 응답 패킷 전송
void CCloseResPacket::CSendPacket(int a_sock)
{
	send(a_sock, &m_close_res_msg, sizeof(dgt_close_res_msg), 0);
}

// 생성자
CSqlReqPacket::CSqlReqPacket()
{
       bzero(&m_sql_req_msg, 0);
}
 
// 생성자
CCloseReqPacket::CCloseReqPacket()
{
	bzero(&m_close_req_msg, 0);
}