Come faccio a gestire le classi che vengono utilizzate una sola volta, ad esempio in una sola funzione?

7

Ho una classe che fondamentalmente crea una versione efficiente della memoria di una struttura da utilizzare in una sezione di codice critica per le prestazioni.

La struttura risultante è brutta ma estremamente veloce, quindi non usarla non è realmente un'opzione, ma non posso nemmeno usarla come unica rappresentazione della mia struttura perché ha parti non rilevanti per l'analisi. Ho già detto che è anche molto brutto?

Chiamiamo questa classe Fast . Ho anche la rappresentazione originale, carina, chiamiamola Pretty . Ho una funzione chiamata Process() che dovrebbe contenere un'istanza di Pretty , convertirla in Fast e poi fare qualche milione di calcoli su di essa e sputare un risultato:

Pretty pretty;
// do stuff with pretty

// in another hpp:
double Process(const Pretty& pretty)
{
  Fast fast(pretty); // create my fast object

  // do some processing on fast

  return result; // at this point fast dies
}

L'istanza di Fast viene creata e muore entro Process , ma sfortunatamente non posso dichiarare una classe all'interno di una funzione, quindi devo dichiararla altrove.

Ciò che vorrei come fare è rendere l'intera classe accessibile solo a Process , e nemmeno averla vista da nessun altro (proprio come farei io al contrario dichiarare una funzione private se la classe fosse l'unico oggetto che avrebbe dovuto accedervi). Ma non posso dichiarare una classe privata!

Ecco il mio tentativo corrente:

class Process
{
public:
  static double DoProcess(Pretty pretty); // this is the process function

private:
  class Fast
  {
    // construct fast here (only Process can see this class!)
  };
};

E poi chiamo Process::DoProcess() . Questo non è davvero un problema critico, quindi non l'ho pubblicato su SO, ma è una domanda di stile e mi piacerebbe davvero avere una soluzione chiara! Non ho mai incontrato prima questo problema e mi sono chiesto come gli altri l'hanno affrontato, e se hanno trovato una soluzione migliore.

    
posta quant 06.07.2014 - 04:55
fonte

2 risposte

8

Riesco a vedere tre opzioni valide qui, dove da una prospettiva di progettazione trovo quella più attraente in basso.

Uno è effettivamente utilizzare il tuo approccio, forse con operator() per evitare la ridondanza.

Un'altra opzione è definire la classe all'interno della funzione stessa (questo è permesso ora).

Tuttavia, è probabile che potresti avere bisogno della classe più tardi, e onestamente dubito che il tuo spazio dei nomi sia così disseminato che non puoi offrire l'ambito del file di classe Fast .

In questo scenario, dichiara il metodo Process nell'intestazione e definiscilo in un file .cpp , sotto la definizione della tua classe Fast , che dovresti racchiudere in uno spazio dei nomi anonimo.

In ogni caso, estrarre la definizione dall'intestazione. La compilazione più rapida è un buon guadagno, ma il più grande vantaggio è mantenere l'interfaccia e l'implementazione separate.

    
risposta data 06.07.2014 - 06:21
fonte
8

Dovresti usare il modello di compilazione separato di C ++ a tuo vantaggio.

C ++ ti permette di definire una classe senza usare un file di intestazione, quindi puoi semplicemente definire Fast nello stesso file sorgente di dove hai la definizione di Process .
Per evitare conflitti di nomi con altre unità che potrebbero anche avere una (diversa) classe Fast , puoi racchiuderla in uno spazio dei nomi anonimo.

In questo modo, sebbene Fast esista per l'intero programma, solo Process può accedervi, poiché questa è l'unica parte in cui è noto il nome di Fast .
Ciò presuppone che Process sia definito all'interno di un file .cpp e non come una funzione incorporata in un file di intestazione. Per le funzioni di qualsiasi complessità, questo è comunque un buon design perché è improbabile che il compilatore li in linea e che possa accelerare significativamente il passo della compilazione.

    
risposta data 06.07.2014 - 08:16
fonte

Leggi altre domande sui tag