Apprendimento del linguaggio C ++ correttamente (non C con le classi) [duplicato]

Per prima cosa, usa l'STL. Soprattutto, conosci i tuoi contenitori ( vector , deque , list , map , set , & c.) E le loro caratteristiche di rendimento. Avere una solida comprensione di dove e come applicare anche le basi ( accumulate , transform , remove_if ) delle primitive algoritmiche definite nell'intestazione <algorithm> . Comprendi che C ++ è un linguaggio multi-paradigma e non provare a forzare tutto nel modello OO.

Se qualcosa che stai facendo non è semplice, leggibile e sicuro per il tipo, è probabile che lo stai facendo in questo modo. Impara gli standard di base di sicurezza di tipo, const correttezza, semantica di riferimento e RAII, tutto ciò che sottilmente ma profondamente imposta C ++ a parte da C. Tieniti aggiornato sugli sviluppi correnti nella lingua (tipo inferenza con auto , lambdas, riferimenti di rvalue) e applicali per migliorare la chiarezza e la qualità del tuo codice.

Leggi buoni libri , blog e altre risorse. Esercizi .

"C with Classes" era il nome originale (o almeno precedente al "C ++") per il linguaggio, ma oggi è usato per trasmettere la sensazione che qualcuno stia scrivendo essenzialmente C usando le caratteristiche minimali di C ++.

@Fred Nurk ha già pubblicato un link alla lista dei libri, quindi non cercherò di entrare nei dettagli, ma prenderei in considerazione C ++ accelerato il primo libro di quella lista per studiare da .

Come per un esempio, consideriamo un programma abbastanza semplice: una versione semplificata del comando standard "sort" di Unix. Per mantenere il codice breve (ma comunque almeno un po 'interessante), facciamolo funzionare come un filtro e produca risultati approssimativamente equivalenti a sort -u . In C con codice di tipo Classes, in genere potresti vedere qualcosa in questo ordine:

#include <iostream>
#include <cstdlib>
#include <cstring>

using namespace std;

const int max_lines = 1024 * 1024; // allow up to one megaline of input.

int sort_func(void const *a, void const *b) { 
    return strcmp(*(char const **)a, *(char const **)b);
}

int main() {
    char buffer[1024];
    char **lines;
    unsigned current_line = 0;

    lines = new char *[max_lines];

    while (cin.getline(buffer, sizeof(buffer))) {
        char *temp = new char[strlen(buffer) + 1];
        strcpy(temp, buffer);
        lines[current_line++] = temp;
        if (current_line == max_lines)
            break;
    }

    qsort(lines, current_line, sizeof(lines[0]), sort_func);

    cout << lines[0];

    for (int i=1; i<current_line; i++)
        if (strcmp(lines[i], lines[i-1]))
            cout << lines[i] << "\n";

    for (int i=0; i<current_line; i++)
        delete [] lines[i];
    delete lines;
    return 0;
}

Ora, questo non è un particolare codice terribile (se fossi del tutto onesto, probabilmente lo renderei peggiore). Passa la dimensione del buffer a getline , quindi il buffer non si sovrapporrà. Quindi assegna un buffer per una linea, copia i dati nel buffer e passa a quello successivo. Controlla anche la fine del file correttamente, ecc.

Paragoniamolo a come probabilmente scriverei il codice in C ++:

#include <iostream>
#include <iterator>
#include <set>
#include <string>

class line { 
    std::string data;
public:
    operator std::string() const { return data; }   
    friend std::istream &operator>>(std::istream &is, line &l) { 
        return std::getline(is, l.data);
    }    
};

int main() { 
    std::set<std::string> lines((std::istream_iterator<line>(std::cin)), 
                                std::istream_iterator<line>());    
    std::copy(lines.begin(), lines.end(), 
              std::ostream_iterator<std::string>(std::cout, "\n"));
    return 0;
}

Questa versione è chiaramente un po 'più breve. Abbiamo anche eliminato la maggior parte dei limiti fissi come la lunghezza massima della linea e il numero massimo di linee. Ancora più importante, tuttavia, non contiene loop espliciti: il loop di input viene gestito implicitamente nel costruttore per il set e il ciclo di output viene gestito nella chiamata a copy . L'ordinamento e l'eliminazione dei duplicati è implicito nella definizione di set.

Leggi cosa pensa il designer di C ++ su Learning C ++ come nuova lingua .

To get the most out of Standard C++ [C++,1998], we must rethink the way we write C++ programs. An approach to such a "rethink" is to consider how C++ can be learned (and taught). What design and programming techniques do we want to emphasize? What subsets of the language do we want to learn first? What subsets of the language do we want to emphasize in real code?

This paper compares a few examples of simple C++ programs written in a modern style using the standard library to traditional C-style solutions. It argues briefly that lessons from these simple examples are relevant to large programs. More generally, it argues for a use of C++ as a higher-level language that relies on abstraction to provide elegance without loss of efficiency compared to lower-level styles...

C ++ è C con classi, alcuni cleanup automatici in distruttori (RAII), eccezioni, polimorfismo, overloading dell'operatore, modelli (generici), insieme a una libreria standard costruita su generici che fornisce raccolte e algoritmi.

Quando dici "C with classes", beh sì, è in una certa misura che gran parte di quanto sopra è parte di ciò che è una caratteristica di una classe.

Se conosci C e desideri imparare il C ++ potresti leggere "C ++ accelerato", anche se in qualche modo potrebbe essere un po 'datato in quanto non sono sicuro che copra shared_ptr che è quasi una parte "da usare" del C ++ ora (parte di C ++ 0x ma disponibile in boost da molto tempo e potrebbe già essere nel tuo std ora).

Quindi dopo "Accelerated C ++" leggi "Oltre la libreria standard".

So che questo sarà controverso, ma per studiare davvero il C ++, non usare i puntatori. I puntatori sono utili in C ++, ma il loro utilizzo all'inizio può influenzare uno a percepire C ++ come "C con classi"

C con classi con una buona organizzazione di file di codice sorgente puoi rendere la tua app più veloce sia per la compilazione che per l'esecuzione, mentre l'abuso del successivo "accademico C ++" aumenterà la compilazione fino a 100 volte più lentamente e la tua applicazione non sarà mai in grado per funzionare correttamente se le prestazioni contano. Nell'azienda su cui lavoro (probabilmente la più grande del settore) hanno alcuni strumenti che impiegano fino a 30 minuti o anche più per compilare, mentre ho scritto la stessa funzionalità per me stesso a casa e i tempi di compilazione sono SOTTO IL MINUTO, e ha molti meno bug ed è molto più manutenibile degli spaghetti di modelli usati al lavoro. Quindi, ciò che conta davvero è se vuoi ottenere il lavoro o se vuoi semplicemente dire di scrivere codice C ++ accademico perfetto.

Ma per realizzare questo, devi codificare molto e imparare come codificare correttamente C con le classi. Il che probabilmente richiederebbe di imparare prima il C ++ accademico :), o no, dipende molto dalle tue capacità, dalla tua volontà e dalla tua perseveranza, quindi non finirai col programmare terribilmente C ++ o C con le classi.