È questo il modo migliore per fare un “con” dichiarazione in C ++?

Question

Modifica

Quindi, la questione è stata male interpretata in misura tale ridicola che non ha più alcun senso. Non so come , in quanto la domanda che ho effettivamente chiesto era se mia implementazione specifica di questo, sì, noto per essere inutile, sì, non lontanamente simile idiomatica C ++ - macro era buono come potrebbe essere, e se doveva necessariamente uso auto, o se c'era una soluzione adatta invece. Non doveva per generare questo molta attenzione, e non certo un equivoco di questa portata. E 'inutile chiedere agli intervistati di modificare le loro risposte, io non voglio che nessuno reputazione perdere su questo, e c'è un po' di informazioni di buona galleggianti intorno a qui per i potenziali spettatori futuri, così ho intenzione di scegliere arbitrariamente una delle inferiore votato risposte per distribuire in modo uniforme la reputazione coinvolti. Si muovono lungo, niente da vedere qui.

---

questa domanda e ho deciso che potrebbe essere divertente da scrivere dichiarazione with in C ++. La parola chiave auto rende il tutto veramente facile, ma c'è un modo migliore per farlo, forse senza usare auto? Ho eliso alcuni bit del codice per brevità.

template<class T>
struct with_helper {

    with_helper(T& v) : value(v), alive(true) {}

    T* operator->() { return &value; }
    T& operator*() { return value; }

    T& value;
    bool alive;

};


template<class T> struct with_helper<const T> { ... };


template<class T> with_helper<T>       make_with_helper(T& value) { ... }
template<class T> with_helper<const T> make_with_helper(const T& value) { ... }


#define with(value) \
for (auto o = make_with_helper(value); o.alive; o.alive = false)

Ecco un (aggiornato) esempio di utilizzo con un caso più tipico che mostra l'uso di with come si trova in altre lingue.

int main(int argc, char** argv) {

    Object object;

    with (object) {

        o->member = 0;
        o->method(1);
        o->method(2);
        o->method(3);

    }

    with (object.get_property("foo").perform_task(1, 2, 3).result()) {

        std::cout
            << (*o)[0] << '\n'
            << (*o)[1] << '\n'
            << (*o)[2] << '\n';

    }

    return 0;

}

Ho scelto o perché è un identificatore non comune, e la sua forma dà l'impressione di una "cosa generico". Se hai un'idea per un identificatore migliore o una sintassi più utilizzabile del tutto, quindi per favore suggerirlo.

Answer 1

?? sintassi vb tentato in C ++

with dice di fare tutte le cose del seguente blocco di default riferimento all'oggetto ho detto di farlo con giusto? esegue una serie di istruzioni fanno riferimento ripetuto per un singolo oggetto o struttura.

with(a)
 .do
 .domore
 .doitall

Quindi, come è l'esempio dando la stessa sintassi?

Per me esempi del perché di utilizzare una con cui multipla de referencess

Quindi, piuttosto che

book.sheet.table.col(a).row(2).setColour
book.sheet.table.col(a).row(2).setFont
book.sheet.table.col(a).row(2).setText
book.sheet.table.col(a).row(2).setBorder

si deve

with( book.sheet.table.col(a).row(2) )
  .setColour
  .setFont
  .setText
  .setBorder

sembra altrettanto facile, e la sintassi più comune in C ++ per

cell& c = book.sheet.table.col(a).row(2);
c.setColour
c.setFont
c.setText
c.setBorder

Answer 2

Se si utilizza auto, perché utilizzare le macro a tutti?

int main()
{
    std::vector<int> vector_with_uncommonly_long_identifier;

    {
        auto& o = vector_with_uncommonly_long_identifier;

        o.push_back(1);
        o.push_back(2);
        o.push_back(3);
    }

    const std::vector<int> constant_duplicate_of_vector_with_uncommonly_long_identifier
        (vector_with_uncommonly_long_identifier);

    {
        const auto& o = constant_duplicate_of_vector_with_uncommonly_long_identifier;

        std::cout
            << o[0] << '\n'
            << o[1] << '\n'
            << o[2] << '\n';
    }

    {
        auto o = constant_duplicate_of_vector_with_uncommonly_long_identifier.size();
        std::cout << o <<'\n';
    }
}

EDIT:. Senza auto, basta usare typedef e riferimenti

int main()
{
    typedef std::vector<int> Vec;

    Vec vector_with_uncommonly_long_identifier;

    {
        Vec& o = vector_with_uncommonly_long_identifier;

        o.push_back(1);
        o.push_back(2);
        o.push_back(3);
    }
}

Answer 3

Per C ++ 0x (che si sta assumendo):

int main() {

    std::vector<int> vector_with_uncommonly_long_identifier;

    {
        auto& o = vector_with_uncommonly_long_identifier;

        o.push_back(1);
        o.push_back(2);
        o.push_back(3);

    }
}

Answer 4

Perché non usare un buon lambda?

auto func = [&](std::vector<int>& o) {
};
func(vector_with_a_truly_ridiculously_long_identifier);

Il semplice fatto è che, se i dati identificativi sono così lunghi, che non si possono digitare fuori ogni volta, utilizzare un riferimento, la funzione, il puntatore, ecc per risolvere questo problema, o meglio, refactoring il nome. Dichiarazioni di questo tipo (ad esempio utilizzando () in C #) hanno effetti collaterali aggiuntivi (pulizia deterministico, nel mio esempio). La sua dichiarazione in C ++ non ha benefici effettivi di rilievo, dal momento che in realtà non invoke qualsiasi comportamento supplementare contro basta scrivere il codice fuori.