class myclass
{
...
   char* array;
   // or
   char array[1000];
}

// myclass.h
#ifndef _MYCLASS_H
#define _MYCLASS_H
class myclass
{
public:
   myclass();
   virtual ~myclass();
  // overload operator
   bool operator<(const char* str);
   bool operator==(const char* str);
   // global overloaded operator that is not part of the class
   friend bool operator<(myclass& mc,const char*s);
 
protected:
  char array[1024];
};
#endif // _MYCLASS_H
 
// myclass.cpp
myclass::myclass()
{
   // initialize array
   memset(array,0,sizeof(array));
}
 
 
bool myclass::operator<(const char*s)
{
  return (strcmp(array,s) < 0) ? true : false;
}
 
bool operator<(myclass& mc,const char* s)
{
   return strcmp(mc.array,s) == 0 ? true : false;
}

#ifndef CPackethdr
#define CPackethdr
class CPacket //Encapsulates data structs and associated information for easier instantiation.
{
public:
	CPacket();
	virtual ~CPacket();
 
	bool operator<(const char* str);   //Included for the purpose of vectorization, but not used.
	bool operator==(const char* str);
 
	struct PeekPacket7
	{
		unsigned short	fProtoSpec;
		unsigned short	fPacketLength;
		unsigned short	fSliceLength;
		unsigned char	fFlags;
		unsigned char	fStatus;
		unsigned long	fTimeStampHi;
		unsigned long	fTimeStampLo;
	}	ppacket;
 
	struct PacketHeader
	{	
		unsigned char	fDestAddr[6];
		unsigned char	fSrcAddr[6];
		unsigned short	fProtocol;
		unsigned char	fPacketData[1500];  /* max packet size */
	}   enetpacket;
 
	int						length;
	unsigned long			packetCount;
	char					timeString[16];
 
};
#endif

 
CPacket::CPacket()
{
	ppacket.fProtoSpec = 0;
	ppacket.fPacketLength = 0;
	ppacket.fSliceLength=0;
	ppacket.fFlags = 0;
	ppacket.fStatus = 0;
	ppacket.fTimeStampHi= 0L;
	ppacket.fTimeStampLo= 0L;
 
	memset(enetpacket.fDestAddr, 0, sizeof(enetpacket.fDestAddr));
	memset(enetpacket.fSrcAddr,0,sizeof(enetpacket.fSrcAddr));
	enetpacket.fProtocol= 0;
	memset(enetpacket.fPacketData,0,sizeof(enetpacket.fPacketData));
 
	length = 0;
	packetCount = 0;
	memset(timeString,0,sizeof(timeString));
}
 
CPacket::~CPacket()
{}
 
 
bool CPacket::operator<(const char* str)
{
	return TRUE;
}
 
bool CPacket::operator==(const char* str)
{
	return TRUE;
}

vector<CPacket> packlist(40);

    memset(&ppacket,0,sizeof(ppacket));
    memset(&enetpacket,0,sizeof(enetpacket));

class CMyDocument : public CDocument
{
  ...
private:
   vector<CPacket> packlist;
};
 
// class constructor
CMyDocument::CMyDocument()
{
   packlist.resize(40);
 
 
};

#if !defined(AFX_TRY5DOC_H__BA63042D_EFBE_45CF_A864_A01C9FB8E010__INCLUDED_)
#define AFX_TRY5DOC_H__BA63042D_EFBE_45CF_A864_A01C9FB8E010__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <vector>

class CPacket //Encapsulates data structs and associated information for easier instantiation.
{
public:
	CPacket();
	virtual ~CPacket();

	bool operator<(const char* str);   //Included for the purpose of vectorization, but not used.
	bool operator==(const char* str);

	struct PeekPacket7
	{
		unsigned short	fProtoSpec;
		unsigned short	fPacketLength;
		unsigned short	fSliceLength;
		unsigned char	fFlags;
		unsigned char	fStatus;
		unsigned long	fTimeStampHi;
		unsigned long	fTimeStampLo;
	}	ppacket;
	
	struct PacketHeader
	{	
		unsigned char	fDestAddr[6];
		unsigned char	fSrcAddr[6];
		unsigned short	fProtocol;
		unsigned char	fPacketData[1500];  /* max packet size */
	}   enetpacket;
	
	int						length;
	unsigned long			packetCount;
	char					timeString[16];
		
};

class CTry5Doc : public CDocument
{
protected: // create from serialization only
	CTry5Doc();
	DECLARE_DYNCREATE(CTry5Doc)

// Attributes
public:
	std::vector<CPacket> theList;

// Operations
public:

// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CTry5Doc)
	public:
	virtual BOOL OnNewDocument();
	virtual void Serialize(CArchive& ar);
	//}}AFX_VIRTUAL

// Implementation
public:
	virtual ~CTry5Doc();
#ifdef _DEBUG
	virtual void AssertValid() const;
	virtual void Dump(CDumpContext& dc) const;
#endif

protected:

// Generated message map functions
protected:
	//{{AFX_MSG(CTry5Doc)
		// NOTE - the ClassWizard will add and remove member functions here.
		//    DO NOT EDIT what you see in these blocks of generated code !
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_TRY5DOC_H__BA63042D_EFBE_45CF_A864_A01C9FB8E010__INCLUDED_)

BOOL CTry5Doc::OnNewDocument()
{
	if (!CDocument::OnNewDocument())
		return FALSE;
	theList.resize(40);
	// TODO: add reinitialization code here
	// (SDI documents will reuse this document)

	return TRUE;
}