Utilizzo di typedef forte come alternativa più leggera alla libreria Boost Parameter?

Question

Spesso uso l'utility Booster strong typedef per migliorare la sicurezza dei miei programmi. Per esempio, scrivendo codice come questo:

BOOST_STRONG_TYPEDEF(int, X) 
BOOST_STRONG_TYPEDEF(int, Y) 
BOOST_STRONG_TYPEDEF(int, Width) 
BOOST_STRONG_TYPEDEF(int, Height) 

struct Rect { 
    Rect(X x, Y y, Width w, Height h); 
}; 

// Usage: 
Rect rect(X(10), Y(20), Width(800), Height(600)); 

La forte typedef qui migliora sia la leggibilità del codice e la sicurezza. (Il compilatore segnala un errore se gli argomenti sono forniti in ordine errato, che non sarebbe stato il caso se gli argomenti erano tutti int.)

Le mie domande sono:

• è ok per utilizzare BOOST_STRONG_TYPEDEF per questo scopo? (La documentazione è very brief.)
• Ci sono motivi importanti per preferire la libreria dei parametri boost invece?

Answer 1

Tecnicamente parlando:

• funziona
• aggiunge digitare sicurezza

In pratica:

non consiglierei la creazione di nuovi tipi solo per il gusto di una singola funzione di parametri (a meno che non sia un enum specifico per questa funzione), i tipi dovrebbero permeare l'applicazione per evitare che i cast vengano usati più e più volte.

Se si utilizzano i tipi di X, Y, Width e Height tutta l'applicazione, quindi, non solo ci sarà alcun cast, ma la vostra applicazione sarà molto più sicuro e molto meglio documentato troppo (yeah ... Sono un tipo maniaco).

Ora, per quanto riguarda Boost.Parameters, questo è completamente diverso.

Boost.Parameters possono (potenzialmente) essere aggiunti quando sono già presenti tipi. Sinceramente non ho mai visto il bisogno. Quando le tue funzioni diventano così ingombranti che è necessario utilizzare Boost.Parameters per chiamarle, devi risolvere le funzioni, non aggiungerle alla confusione.

Answer 2

L'utilizzo di BOOST_STRONG_TYPDEF sta creando un nuovo tipo, in cui la libreria dei parametri boost è dedicata ai nomi dei parametri. Ti consente di essere più esplicito con le tue funzioni. Per esempio (dalla documentazione spinta)

#include <boost/parameter/preprocessor.hpp> 

namespace graphs 
{ 
    BOOST_PARAMETER_FUNCTION(
     (void),    // 1. parenthesized return type 
     depth_first_search, // 2. name of the function template 

     tag,     // 3. namespace of tag types 

     (required (graph, *)) // 4. one required parameter, and 

     (optional    // four optional parameters, with defaults 
     (visitor,   *, boost::dfs_visitor<>()) 
     (root_vertex,  *, *vertices(graph).first) 
     (index_map,   *, get(boost::vertex_index,graph)) 
     (in_out(color_map), *, 
      default_color_map(num_vertices(graph), index_map)) 
    ) 
) 
    { 
     // ... body of function goes here... 
     // use graph, visitor, index_map, and color_map 
    } 
} 

Consente di dire esplicitamente cosa ci si aspetta, quasi in un disegno per contratto sorta di passaggio. Tuttavia trovo che questo complica la leggibilità del tuo codice abbastanza da renderlo irrilevante.

Personalmente preferisco utilizzare BOOST_STRONG_TYPEDEF perché crea un nuovo tipo "che può essere utilizzato per la corrispondenza di parametri di funzione o di modello" (di nuovo dalla documentazione di boost).