Learning C++ properly (not C with classes) [duplicate]

Question

The typical reason I hear to why people bash C++ is that they don't actually know C++, they just know "C with classes", which apparently is different. I am just beginning to learn C++, however, I want to actually learn C++ and not simply "C with classes". How can I ensure I learn C++ properly? Some examples would be wonderful.

Answer 1

For one thing, use the STL. Above all, know your containers (vector, deque, list, map, set, &c.) and their performance characteristics. Have a solid understanding of where and how to apply even the basics (accumulate, transform, remove_if) of the algorithmic primitives defined in the <algorithm> header. Understand that C++ is a multi-paradigm language, and don’t try to force everything into the OO model.

If something you’re doing isn’t plain, legible, and type-safe, chances are you're doing it the C way. Learn the basic standards of type safety, const correctness, reference semantics, and RAII, all things that subtly but profoundly set C++ apart from C. Keep up to date on current developments in the language (type inference with auto, lambdas, rvalue references) and apply them to improve the clarity and quality of your code.

Answer 2

Read good books, blogs, and other resources. Practice.

"C with Classes" was the original (or at least predating "C++") name for the language, but today it is used to convey the sense that someone is essentially writing C using minimal convenience features of C++.

Answer 3

@Fred Nurk has already posted a link to the book list, so I won't try to go into detail, but I'd consider Accelerated C++ the first book on that list to study from.

As for an example, let's consider a fairly simple program: a simplified version of the standard Unix "sort" command. To keep the code short (but still at least a little interesting), let's have it operate as a filter, and produce results roughly equivalent to sort -u. In C with Classes type code, you might typically see something on this order:

#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;
}

Now, this isn't particular terrible code (if I was being entirely honest, I'd probably make it worse). It passes the buffer size to getline, so the buffer won't overflow. It then allocates a buffer for a line, copies the data to the buffer, and goes on to the next. It even checks for the end of file correctly, etc.

Let's compare that to how I'd probably write the code 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;
}

This version is clearly a bit shorter. We've also eliminated most of the fixed limits such as the maximum line length and maximum number of lines. More importantly, however, it contains no explicit loops -- the input loop is handled implicitly in the constructor for the set, and the output loop is handled in the call to copy. Sorting and eliminating duplicates is implicit in the definition of set.

Answer 4

Read what the designer of C++ thinks on Learning C++ as a new language.

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...

Answer 5

C++ is C with classes, some automatic-cleanup in destructors (RAII), exceptions, polymorphism, operator overloading, templates (generics), together with a standard library built on generics that gives you collections and algorithms.

When you say "C with classes", well yes it is to some extent as much of the above is part of what is a feature of a class.

If you know C and wish to learn C++ you might read "Accelerated C++", although to some extent that may be a bit dated as I am not sure it covers shared_ptr which is almost a "must use" part of C++ now (part of C++0x but available in boost for a long time now and may be already in your std now).

Therefore after "Accelerated C++" read "Beyond the Standard Library".

Answer 6

I know this is going to be controversial but to really study C++, don't use pointers. Pointers are useful in C++, but their usage in beginning may influence one to perceive C++ as 'C with classes'

Answer 7

C with classes with a good organization of source code files you can make your app faster for both compiling and running, while abusing of the later "academic C++" will increase compiling up to 100 times slower and your application will never be able to run properly if performance does matter. In the company I work on (probably the biggest in its sector) they have some tools that take up to 30 minutes or even more to compile, while I wrote the same functionality for myself at home and the compiling times are BELOW THE MINUTE, and it does have many less bugs and is far more maintainable that the spaghetti of templates used at work. So what really matters is if you want to get the job done or if you just want to say you code perfect academic C++.

But to realize this, you have to code a lot and learn how to properly code C with classes. Which probably would require you to learn academic C++ first :), or not, it depends a lot on your skills and will and perseverance, so you don't end up coding terrible either C++ or C with classes.