Language Comparison

Synopsis:

C++ is based on a C language core. Most C programs will compile as C++ programs. C++ adds:

C++ references
Function overloading
classes
Scope-based resource management
Inheritance
templates
I/O Streams
template containers

Inheritance and templates allow us to build very flexible code that is easy to reuse and that gracefully accomodates changes in requirements. That only happens if you use good design practices.

These are excellent references for the C++ language:

CppReference.com, cplusplus.com, C++ FAQ

Similarities between C and C++

Most C programs will compile as C++ programs.
They share the same compilation model, vsd.
Both generate native code and allow programs to directly manage resources.
Both can use platform APIs by consuming platfrom header files and linking to platform libraries.
Both have scopes, vsd that are compile-time only artifacts and other scopes that have run-time behavior:
- Compile-time scopes:
  - C struct and enum scopes.
  - C++ namespace, class/struct, and enum scopes
- Both have the same Run-time scopes:
  - Function, looping, selection, and anonymous scopes
  - Entering a run-time scope causes a stack frame to be allocated to hold local data, e.g., scratch-pad memory.
  - When the thread of execution leaves a scope its stack frame becomes invalid. The next time a scope is entered that memory may be reallocated to the new scope.
C++ can use the Standard C library (but usually doesn't need to).
- Standard C and C++ Libraries
Both are relatively strongly typed; both allow escaping the type system with casts.
Both have the same primitive types, use static arrays and structs, and have string libraries.
C and C++ structs support composition (hold another struct) and aggregation (hold a pointer to another struct)
Both use the same pointer syntax.
They share the same memory models, vsd.

Differences between C and C++

Programs written in C++ include system libraries without the .h extension, e.g., #include<iostream>. The C Language libraries are still available. Instead of using #include <stdio.h> use #include <cstdio>.
C++ adds references to the type system.
- C++ references wrap pointers. The wrapper provides the same object syntax as the type referenced.
- Unlike pointers, C++ references must be bound at declaration and cannot be reset to refer to a different object.
C functions pass and return by value. C++ functions pass and return by both value and reference.
- C and C++ functions can both pass and return pointers, but C++ references provide simpler syntax in many contexts.
C++ functions can be overloaded. Overloaded functions share the same name, but must have a different sequence of parameter types.
- To support function overloading the compiler uses mangled names which consist of the name and parameter sequence in tokenized form. It is the mangled name that gets bound to a code block for execution.
- Overloading is essential for C++ classes, as we will see below.
C++ introduces classes.
- C++ classes have both data and function members.
- classes provide access control, e.g., public, protected, and private access.
- class instances can be declared in static memory, stack memory, or on the heap, using new and delete.
- C++ structs are identical to C++ classes except for their default access levels - public for structs, private for classes.
C++ classes have an elegant resource management process:
- Member functions that have the same name as their class are constructors, responsible for initializing a newly created instance.
- C++ supports default construction, parameterized construction, copy construction, and move construction. We will discuss all of these when we look at the anatomy of classes in the next slide.
- Any function with name the same as the class but prepended with a tilde (~) is a destructor.
- when a class instance is declared in some scope the instance is intialized at the point of declaration and destroyed when the thread of execution leaves that scope.
- This means that, for correctly defined classes, code using a class does not have to participate in any way with resource allocation and deallocation for any locally defined instance. That all happens automatically.
C++ classes can support either value type or reference type behavior.
- Value types can be copied, so the copy appears to have the same state as the original instance, even if instances of the class hold pointers to resources on the native heap. C++ provides facilities for building copy constructors that manage copy operations and support overloading of assignment operations to correctly manage assignment of the heap resources. Note that managed code languages like Java and C# do not provide means to do that.
- Reference types hold pointers to resources on the heap, but copying and assignment just copy and assign the references, not the resources they refer to. C++ supports building reference types by using std::unique_ptr to transfer ownership for copy and assignment operations. It also provides std::shared_ptr to share ownership of a resource using reference counting, so the resource is not deallocated until all references go out of scope or are set to nullptr.
- Note that when we use the term reference type we are not talking about the C++ reference wrapper, but rather a class that manages some resource with an internal pointer and does not copy or assign the state of that resource. In a sense a reference type is a generalization of the C++ reference.
C++ classes support Inheritance and may have virtual functions which are dispatched at run-time via Virtual Function Pointer Tables (vtbl), vsd.
C++ uses the new and delete operators for memory management. A call to new allocates memory on the native heap, and is guaranteed to initialize the allocation with a constructor call. Invoking delete on an instance in the heap calls it's destructor to return resourses to the system.
Inheritance supports:
- code sharing - all derived classes share the same non-virtual function implementations.
- specializing derived types by overriding virtual member functions.
- substitution:
  Any function that accepts a base class pointer or reference will accept a pointer or reference to a class derived from that base.
- Parser example
C++ provides template syntax to support generic programming. We can, in library code, implement classes and functions that depend on a parameter not specified until an application instantiates the template. The C++ containers are all defined with template classes.
Error handling can use exceptions, using the key words try, catch, and throw. Exceptions enable handling errors without constantly checking returned error codes.
The standard C++ library provides:
- I/O Streams
- A rich set of template containers: vectors, queues, lists, maps, and hashtables
- A family of algorithms that works effectively with the contains
- Threads and synchronization constructs

We will see examples of all of these C++ language artifacts in the code examples to follow.

C++ Philosophy:

Provide mechanics for strong encapsulation - only member functions of classes can access private data managed by the class. That means that a well-designed class can make strong guarantees about the integrity of its managed data.
Attempt to pay for features at compile-time rather than run-time, e.g., no built-in index bounds checking, no garbage collection, and no built-in error handling. Note, however, if you want those features it is relatively easy to provide them for your classes, either by using library facilities or rolling your own.
In the spirit of C, prefer to enable developers rather than protect them.