Progettazione per un algoritmo che segnala i progressi

Hai considerato un modello di "pompa"? Esternalizzare l'iterazione effettiva e memorizzare lo stato completo richiesto per riprendere l'iterazione all'interno delle variabili / struttura che esegue il calcolo. Quindi, ogni iterazione, leggi una sorta di variabile di stato di avanzamento che viene scritta dall'algoritmo.

Mi sembra che, a causa del linguaggio primitivo con cui sei bloccato, sei limitato ad alcuni semplici approcci che non sono ideali.

Per aggiungere un aspetto C ++ a questo, il C ++ moderno ha diverse soluzioni al # 3. È possibile associare praticamente qualsiasi entità callable compatibile (che si tratti di una funzione, un oggetto funzione o una funzione membro) utilizzando std::bind , utilizzare std::function per lo stesso compito o utilizzare una funzione lambda.

Tutte e tre le possibilità sono supportate dal prossimo standard C ++ (che dovrebbe essere rilasciato quest'anno). Le due soluzioni di libreria sono già fornite da quasi tutti i compilatori (anche se potrebbero essere nello spazio dei nomi std::tr1 , piuttosto che std ), e se non possono essere usate come parte delle librerie boost fenomenali (quindi nello spazio dei nomi boost ). Le funzioni Lambda sono implementate dalle recenti versioni VC e GCC.

Penso che il modo più semplice per farlo sarebbe quello di rendere il parametro callback un argomento modello o std::function<void(progress_info_t)> .

Stai facendo un processo iterativo le cui proprietà di convergenza non sono facilmente prevedibili, ma che desideri continuare fino a quando non converge, o se ne deduce in profondità doo-doo? Se non "stampa" informazioni sul suo progresso (numero di iterazioni, un residuo (o qualsiasi altra figura di progresso ha senso), allora l'utente potrebbe essere preoccupato, "è nei guai? Potrebbe essere appeso, o essere in un ciclo infinito? ". Quindi una cosa sarebbe memorizzare queste proprietà in un indirizzo (o file esterno) che può essere letto da qualche processo di monitoraggio o la tua preoccupazione è molto diversa da questa?

Passa il riferimento alla tua funzione di callback come parametro aggiuntivo nel tuo algoritmo.

Se non vuoi preoccuparti dei richiami di questa chiamata, passa una semplice funzione di stub che non fa altro che restituire.

A seconda della natura del prodotto, ho conosciuto più di un paio di sviluppatori che hanno appena messo una barra di avanzamento scorrevole che va avanti ogni secondo o due (qualche percento per tick), che non ha nulla a che vedere col progresso effettivo. C'è una callback alla fine per farla lampeggiare al 100% (o meno). È un trucco totale, ma di nuovo una barra di avanzamento è solo uno strumento per dire all'utente "per favore aspetta, sì il programma non si è rotto ed effettivamente sta facendo qualcosa".

Se stai parlando di una notifica di avanzamento dell'installazione complicata, non è una buona idea, ma per qualcosa che potrebbe richiedere 30 secondi o meno va bene.

In altre parole, se si tratta di una piccola operazione, non preoccuparti di essere super preciso, o addirittura rappresentativo, nel tuo resoconto dei progressi.

Poiché non c'è una risposta accettata, lancio una possibile soluzione. Hai provato un disegno in cui i valori sono osservabili al posto dell'algoritmo?

In c ++ avrei fatto qualcosa di simile a questo:

template <typename T>
struct observable
{
typedef function<void(const T&)> observer;

list<observer> observers;

T val;

void notify(const T& val)
{
    for(auto&& o : observers)
        o(val);
}

void operator=(const T& val)
{
    this->val = val;
    notify(this->val);
}

void watch(const observer& obs)
{
    observers.push_back(obs);
}

};

E poi nel mio algo:

struct myalgo
{
observable<info> _info;

void do_work(params)
{
    info myinfo;
    do { job(); info.x = "info1" info.y = "info2"; _info = myinfo; }
    while (!has_to_stop());
}