Unhandled exception when using difftime()

Question

I am creating a program that reads in data about fireworks from an XML file (such as type, colour, time in milliseconds it launches and how long it lasts for etc). This then displays the fireworks display using openGL in a loop.

My approach to this is to have a manager class, that takes in a vector of the xml read fireworks and moves them between 3 different vectors: inactiveFireworks (those that are yet to fire), activeFireworks (those that need to be animated) and depletedFireworks (those that will be pushed back to inactiveFireworks when the display is run).

To check to see if a firework needs to be fired, I need to work out the difference between the time the firework manager was called and the current time of the program and multiply that by 1000 to get milliseconds.

eg: if a firework is due to fire at 3000, it will be called 3 seconds in to the existence of the fire work manager.

Unfortunately, I get an unhandled exception error at this point and I'm not sure why...

timeDifference = difftime(time(&currentTime),initTime) * 1000;

here is the header file:

#ifndef FWORKMANAGER_H
#define FWORKMANAGER_H

#include <Time.h>
#include <vector>
#include "firework.h"

class fworkManager
{
private:
    time_t initTime;
    time_t currentTime;
    double timeDifference;

    std::vector<firework*> inactiveFireworks; 
    std::vector<firework*> activeFireworks; 
    std::vector<firework*> depletedFireworks; 

public:
    fworkManager(std::vector<firework*> fListIn);
    void drawAllFireworks();

    void evolve();
    void fireInactiveFireworks();
    void moveActiveFireworks();
    void moveDepletedFireworks();
    void reset();   
};

#endif

And here is the CPP.

#include <vector>
#include "LUtil.h"
#include "fworkManager.h"

fworkManager :: fworkManager(std::vector<firework*> fListIn){
    inactiveFireworks = fListIn;
    time (&initTime);
}

//animates fireworks
void fworkManager::evolve(){
    //check time against inactiveFireworks

    fireInactiveFireworks();
    moveActiveFireworks();
    moveDepletedFireworks();
    reset();
}

//draws fireworks as they come up
void fworkManager::drawAllFireworks()
{
    std::vector<firework*>::iterator i;

    for(i=activeFireworks.begin(); i != activeFireworks.end(); i ++)
    {
        (*i) -> draw();
    }
}

//if fireworks are ready to fire, push them to active list
void fworkManager::fireInactiveFireworks()
{
    timeDifference = difftime(time(&currentTime),initTime) * 1000;
    std::vector<firework*>::iterator i;

    for(i = inactiveFireworks.begin(); i != inactiveFireworks.end();)
    {
        if((*i) -> getBegin() <= timeDifference)
        {
            activeFireworks.push_back(*i);
            (*i) -> explode();
            i = inactiveFireworks.erase(i);
        }else{
            ++i;
        }
    }
}

//animate each firework in the active list
void fworkManager::moveActiveFireworks()
{
    std::vector<firework*>::iterator i;
        for(i = activeFireworks.begin(); i != activeFireworks.end(); i++)
    {
        (*i) -> evolve();
    }
}

//move fireworks that have met their duration requirement to the depleted list.
void fworkManager::moveDepletedFireworks()
{
        std::vector<firework*>::iterator i;
    for(i = activeFireworks.begin(); i != activeFireworks.end();)
    {
        if((*i) -> getLifeSpan() >= (*i) -> getDuration()  )
        {
            depletedFireworks.push_back(*i);

            i = activeFireworks.erase(i);
        }else{
            ++i;
        }
    }
}

//repopulates the inactive firework list and resets the time difference. Allows animation to loop.
void fworkManager::reset()
{
    if(inactiveFireworks.empty() && activeFireworks.empty())
    {
        time (&initTime);
        std::vector<firework*>::iterator i;
        for(i=depletedFireworks.begin(); i != depletedFireworks.end();)
        {
            (*i) -> reset();
            inactiveFireworks.push_back(*i);
            i = depletedFireworks.erase(i);

        }

    }
}

Many Thanks for any insight offered.