Rileva modifica della variabile in fase di esecuzione in C/C++

Question

Sto sviluppando una libreria in C++ in cui gli utenti/programmatori estenderanno una classe BaseClass che ha un metodo initArray. Questo metodo dovrebbe essere implementato dall'utente/programmatore e normalmente dovrebbe inizializzare tutti gli elementi dell'array m_arr.

Ecco una snipplet, modificato per questo esempio:

class BaseClass { 
    public: 

    BaseClass(int n) { 
     m_arr = new double[n]; 
     size = n; 
    }; 
    virtual ~BaseClass(); 

    int size; 
    double* m_arr; 

    virtual int initArray(); 
}; 

A volte, l'utente/programmatore implementa una initArray che non inizializza alcuni elementi di m_arr. Quello che vorrei è creare una funzione nella mia libreria che controlli se initArray ha inizializzato tutti gli elementi di m_arr. Questa funzione deve essere richiamata da una routine di controllo di integrità al runtime .

La mia domanda: è possibile rilevare le modifiche su questo array? Posso solo pensare di inizializzare l'array con alcuni valori non validi (come NaN o Inf), chiamare initArray e controllare che tutti i valori siano cambiati.

Grazie per le vostre idee,

David

---

Modifica

Ecco un esempio del codice client che sto cercando di rilevare:

// .h: 
class MyExample : public BaseClass { 
    public: 
    MyExample(); 
    virtual ~MyExample(); 
    virtual int initArray(); 
}; 

// .cpp: 
MyExample::MyExample() : BaseClass(3) { } 
MyExample::~MyExample() { } 
int MyExample::initArray() { 
    m_arr[0] = 10; 
    //m_arr[1] = 11; // let's say someone forgot this line 
    m_arr[2] = 12; 
    return 0; 
} 

Quindi, dimenticando lo m_arr[1] questo elemento non è inizializzato e potrebbe causare problemi nei calcoli futuri. Questo è quello che vorrei controllare.

Answer 1

Non vedo un modo semplice per farlo in C++. Quello che intendi implementare sono i filtri in Ruby on Rails dove prima di accedere a qualsiasi metodo, i filtri sono invocati.

In alternativa è possibile avvolgere la matrice in una struttura e all'interno di questa struttura sovraccaricare l'operatore [] per l'assegnazione e l'accesso.

Ora:

1) All'interno della sovraccarico [] operatore per l'assegnazione, mantenere un contatore e incrementare il contatore per ogni inizializzazione.

2) All'interno dell'operatore di accesso [] sovraccarico, controllare il contatore prima di accedere ai contenuti dell'array se è uguale al numero totale di elementi. In caso contrario, lanciare un errore.

Spero che questo aiuti.

Answer 2

Perché non utilizzare un vettore std ::? L'utente finale aggiungerà quindi a esso utilizzando push_back e sarà possibile controllare la dimensione per vedere quanti elementi sono stati aggiunti.

Answer 3

L'idea di utilizzare inf o NaN funzionerebbe. Qualsiasi inizializzatore predeterminato funzionerebbe abbastanza bene.

Un'altra idea è creare una funzione membro di accesso per modificare elementi. Nella finestra di accesso si imposta il flag modificato, in InitArray() si cancella il flag modificato.

Answer 4

Questo dipende da cosa si sta tentando di fare: è effettivamente necessario creare l'array nella classe base oppure è possibile utilizzare il suggerimento di Neil di push_back()?

In ogni caso, è consigliabile utilizzare un std::vector<> (perché la gestione della memoria?) Di boost::optional<double>. (Sai dello boost libraries?)

Inoltre, vuoi veramente dividere la creazione dell'oggetto in due fasi? Qualsiasi codice client che crea un discendente BaseClass deve chiamare initArray(). Sei preoccupato per l'efficienza?

Answer 5

Ecco la mia proposta:

Aggiungi un altro metodo virtuale protetto alla classe base, che chiama "InitArrayImpl" e ordinare il creatore della sottoclasse per riempire la matrice in esso.

Il metodo initArray deve essere pubblico non virtul, in questo metodo, effettuare una chiamata a InitArrayImpl, prima della chiamata, inizializzare l'array con valori non validi, dopo la chiamata, verificare se tutti i valori sono stati modificati.

Il client della classe deve essere esposto solo al metodo initArray.

Answer 6

Se stai cercando di creare un'interfaccia "infallibile", piuttosto che pensare a initArray() come una routine con effetti collaterali ... perché non stilizzarlo come qualcosa di più funzionale? initArray() potrebbe avere la responsabilità di allocare e costruire un vettore e ritrasferire un riferimento a quell'oggetto completamente costruito. Ciò consentirebbe anche di effettuare m_arr privato:

class BaseClass { 
private: 
    size_t size; 
    auto_ptr< vector<double> > m_arr; 

public: 
    BaseClass(size_t n) { 
     size = n; 
    }; 
    virtual ~BaseClass(); 

protected: 
    virtual auto_ptr< vector<double> > initArray() const; 
}; 

(Nota: Dopo aver chiamato initArray è possibile verificare che il vettore della classe derivata passa di nuovo è la dimensione giusta O se non avete bisogno di far rispettare. la dimensione in avanti, si può solo annullare quel parametro dal costruttore e accettare qualsiasi lunghezza initArray restituisce come dimensione desiderata.)

Answer 7

Penso che tu stia fischiando nel vento su questo. Non è possibile dettare che tutti i valori siano correttamente compilati. Nel migliore dei casi tutto ciò che si può fare è dettare che l'utente inserisce qualche valore negli elementi dell'array. Se metti i NaN nell'array che controlli quindi, tutti gli utenti faranno un'inizializzazione con zero, -1 o MAX_DOUBLE. Quindi potresti anche dare loro un ctor per farlo e averne fatto.

La mia classe derivata potrebbe utilizzare la classe base per riservare 1000 elementi ma potrebbe contenere il proprio conteggio di quanti elementi ha effettivamente utilizzato.

Answer 8

Se l'efficienza non è uno dei vostri principali obiettivi, si può

• Blocca l'accesso diretto alla m_arr rendendolo privato
• aggiungere array di Caccio della stessa dimensione come m_arr m_field_initialized = new bool[n] e inizializzare con valori falsi.
• Crea istanza pubblica (o protetto) di classe di accesso che vi avvolgerà m_arr e m_field_initialized
• Accessor dovrebbe avere setVal(int i, double val) metodo che definirà m_arr[i] e additionaly m_field_initialized[i] bandiera true;
• Nel test di verifica del test di inizializzazione se tutti i campi di m_field_initialized sono stati impostati su true.

È possibile migliorare questo fornendo un metodo per un accesso diretto più rapido, quando sono state soddisfatte le condizioni di inizializzazione. Restituisce un puntatore nullo prima del controllo di inizializzazione e, una volta completata l'inizializzazione, restituisce il puntatore dell'array.

double * directAccess() { 
    if (m_arr_initialized) return m_arr; 
    else return 0; 
} 

m_arr_initialized è fissato per il metodo di controllo di inizializzazione.

---

Se non è richiesta per la matrice da allocare nella classe base è possibile impostare m_arr a zero, lasciare allocazione per sottoclassi e solo controllare se m_arr puntatore è stato impostato diverso da zero. È possibile impostare un campo valido aggiuntivo che denoti la dimensione allocata.In alternativa, puoi bloccare l'accesso a m_arr e fornire il metodo nella classe base per l'allocazione allocate(std::size_t size) o l'allocazione con il valore iniziale allocate(std::size_t size, double initVal) oppure imporre la funzione di inizializzazione da passare allocate(std::size_t size, double (*callback)(std::size_t element)), che verrà richiamata su ciascun elemento. Ci sono molte possibilità.

---

edit: dopo la modifica suggerisco un puntatore (o di riferimento) a uno oggetto inizializzazione o richiamata ad una funzione nel costruttore BaseClass. Ciò imporrà le sottoclassi per fornire il codice di inizializzazione. Si consideri il seguente:

class InitializerInterface 
{ 
    public: 
    virtual double get(int element) const = 0; 
} 

Nella tua classe base costruttore

BaseClass(int n, const InitializerInterface & initializer) { 
    m_arr = new double[n]; 
    size = n; 
    for (int i = 0; i < n; i++) 
     m_arr[i] = initializer.get(i); 
}; 

Ora, qualsiasi sottoclasse deve passare un po 'di inizializzazione al costruttore. Ovviamente è possibile sostituire il metodo get() con un functor o aggiungere anche il supporto per la funzione callback. Dipende dalle tue preferenze.

// ultima modifica per renderlo const-corretto

Answer 9

Questo appare meno come C++ e più simile a C con un paio di caratteristiche utili come costruttori per me. La tua classe non può prendere una decisione se si tratta di una classe C-struct o C++ e penso che sia parte del problema che stai avendo con l'inizializzazione qui.

Cosa fare in questo modo in un modo diverso, rendendo privato l'array e fornendo un'interfaccia di inizializzazione non virtuale che accetta un tipo di functor simile a std :: generate. Quindi chiama il funtore una volta per ciascun elemento. In questo modo sai se hanno chiamato il tuo inizializzatore e sai che tutti gli elementi sono inizializzati in modo sicuro. Non solo, vengono quindi protetti dalle classi dei bambini cambiandoli quando lo desiderano.

Se per un motivo o l'altro è necessario mantenere l'approccio corrente, l'utilizzo di NaN o inf potrebbe funzionare se è possibile garantire che tali valori non catturino un'eccezione su qualsiasi hardware per cui si prevede di rilasciare la libreria. Più sicuro, basta scegliere un valore neutro come 0 o uno e se il client non riesce a inizializzare, è sufficiente chiarire che si stanno sparando ai loro piedi.

In altre parole, avere tali dati essere pubblici E far rispettare che viene inizializzato sanamente sono due (quasi) obiettivi che si escludono a vicenda.

Answer 10

È anche possibile impostare un punto di interruzione dei dati tramite registri di debug. Questo link ha alcune informazioni sull'argomento.