C / C++ / MFC

void SetPoints(size_t time, double* values, size_t count)<br />
	{<br />
		m_time = time;<br />
		m_values = values;<br />
		m_pointsCnt = count;<br />
<br />
		if (m_points) <br />
			delete [] m_points; //line that encounters error<br />
		m_points = new POINT[m_pointsCnt];<br />
		<br />
		_UpdateYRange();<br />
		_Recalc();<br />
	}<br />

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

"Opinions are neither right nor wrong. I cannot change your opinion. I can, however, change what influences your opinion." - David Crow

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

struct JobCodeNode
{
    // these should be at the first 8 bytes, so you can manipulate them without 
    // typecasting them to the actual type
    JobCodeNode* pNext;
    JobCodeNode* pPrev; // leave this out if you don't need a bi-directional list

    JobCode* pNode;
};

struct LinkedList
{
    void* pStartNode;
    void* pCurrentNode; // more difficult to implement, but certainly speeds up things
};

// functions that traverse the list
LinkedList InitLList(void* pStart)
{
    LinkedList LList;
    LList->pStartNode = pStart;
    LList->pCurrentNode = pStart;

    // you can initialize the start node too
    ((int*)pStart) = NULL; // next node
    ((int*)(pStart + 4)) = NULL; // prev node

    return LList;
}

// other traversing routines

/* myinclude.h */
#define LISTHANDLE (void*);
LISTHANDLE List_Create(size_t record_size);
size_t List_Size(LISTHANDLE hList);
int List_Append(LISTHANDLE hList, void* pRecord);
int List_ReadNext(LISTHANDLE hList, void* pRecord);
int List_Insert(LISTHANDLE hList, void* pRecord);
int List_Sort(int (*callback)(void*,void*));
/*
 etc...
*/
/* mysource.c */
#ifndef BYTE
#define BYTE unsigned char
#endif
typedef struct st_NodeHeader
{
    struct st_NodeHeader* pNext;
} NODE_HEADER;

typedef struct st_Header
{
    size_t nRecSize;
    NODE_HEADER* pHead;
    NODE_HEADER* pTail;
    NODE_HEADER* pCurrent;
} HEADER;

LISTHANDLE List_Create(size_t record_size)
{
    HEADER* pHeader = (HEADER*)malloc(sizeof(HEADER));
    if( pHeader )
    {
        memset(pHeader,0,sizeof(HEADER);
        pHeader->nRecSize = record_size;
    }
    return(pHeader);
};

int List_Insert(LISTHANDLE hList, void* pRecord)
{
    if( hList && pRecord )
    {
        HEADER* pHeader = (HEADER*)hList;
        size_t nNodeSize = sizeof(NODE_HEADER) + pHeader->nRecSize;
        NODE_HEADER* pNode = (NODE_HEADER*)malloc(nNodeSize);
        if( pNode )
        {
            BYTE* pRec = ((BYTE*)pNode) + sizeof(NODE_HEADER);
            pNode->pNext = (NODE_HEADER*)0;
            memcpy(pRec,pRecord,pHeader->nRecSize);
            /*
            Add node to list like normal
            .......
            */
            return(1);
        }
    }
    return(0);
}

int List_ReadNext(LISTHANDLE hList, void* pRecord)
{
    if( hList && pRecord )
    {
        HEADER* pHeader = (HEADER*)hList;
        if( pHeader->pCurrent )
        {
            BYTE* pRec = ((BYTE*)pNode) + sizeof(NODE_HEADER);
            memcpy(pRecord,pRec,pHeader->nRecSize);
            pHeader->pCurrent = pHeader->pCurrent->pNext;
            return(1);
        }
    }
    return(0);
}