C vs. C++: Some important differences

Intro

C has been around since around 1970 (or before)
C++ was based on the C language
While C is not actually a strict subset of C++, most C code can be handled by a C++ compiler
For your reference, I'm listing some of the major differences here
- Most of this will consist of illustrating what code works in both, versus what code works only in C++
- This will be useful if (and when) you have to write code in strict C
- See the "Formatted I/O in C" page for the descriptions of printf/scanf basics

`#include` statements

The older C-style way of including libraries looks like this:

 #include <stdio.h>
 #include <string.h>
 #include <math.h>
 #include <ctype.h>

C++ also used to use this format, but moved to a new style shortly before the 1998 C++ standard. C++ libraries use just the library name, without the .h filename extension:
```
 #include <iostream>
 #include <iomanip>
 #include <vector>
```
And when including C libraries (in C++), now we drop the .h and add c to the front (to identify them as C libraries):
```
 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <cctype>
```

Keywords

These keywords are common to C and C++:

 auto        break      case        char       const        continue
 default     do         double      else       enum         extern 
 float       for        goto        if         int          long
 register    return     short       signed     sizeof       static
 struct      switch     typedef     union      unsigned     void
 volatile    while

These are some keywords that were added into C++

 static_cast        bool         catch      class       delete 
 dynamic_cast       explicit     false      friend      inline
 const_cast         namespace    new        operator    private
 reinterpret_cast   protected    public     template    this
                    throw        true       try         typename
                    using        virtual

Note: This is not a comprehensive list. This list contains the keywords we have seen so far, as well as other important ones that will be covered in the Object-Oriented Programming course. For a more complete list, see the chart in the textbook, chapter 2

These keyword lists already help identify some of the C++-only features, things that were added into C++ but are not allowed in strict C coding. Such C++-only features (easily identified by the keyword lists) include:
- the Boolean type (bool)
- the 4 specific cast operations (compared to older C-style casting)
- classes and objects
- namespaces and using statements
- exception handling (with try, catch, throw)
- using new and delete for dynamic memory management
  - C uses library functions malloc() and free(), and other variations of those functions
- templates

Other C++-only Features

In addition to the ones listed above, here are some other features already discussed in the course, which are C++-only features (not legal in strict C coding):

Function overloading -- the ability to have multiple functions with the same name (in the same scope), by giving them different parameter lists
Default values on parameters (making the parameters optional)
Alternate form of variable initialization:
```
  int num(10);		// equivalent to:  int num = 10;
```
Remember that this was a legal form in C++. Not legal in C.
Pass by reference -- In C, there is no "by reference" - parameters and/or returns are either regular variables (pass-by-value) or pointers (pass-by-address). The array style parameter notation is still fine:
```
  void Func(int arr[], int size);	// legal in C
  void Func(int* arr, int size);	// equivalent prototype
```

Structs and Enumerations: C vs. C++

In both C and C++, the struct definition is the same:

 struct Student
 {
    char firstName[20];
    char lastName[20];
    int studentID;
    double gpa;
 };

But in C++, the structure "tag" (or name) is now a new type. In C, we still have to use struct when declaring a variable or a function prototype:

   Student s1, s2, s3;		// C++ declaration of Student variables
   void Print(Student s);	// C++ function prototype

   struct Student s1, s2, s3;	    // C declaration of Student variables
   void Print(struct Student s);    // C function prototype

However, in C you can make a single word as a new type name for a struct type by using a typedef statement:

 typedef struct student		// this is the structure "tag"
 {
    char firstName[20];
    char lastName[20];
    int studentID;
    double gpa;
 } Student;			// this is now the new type name
  
 struct student s1;		// C declaration using regular "tag"
 Student s2;			// C declaration using new type name

The same thing goes for enumerations, with the keyword enum

  enum Suit {CLUBS, HEARTS, DIAMONDS, SPADES};

  Suit s;		// C++ declaration.  Suit is now a type
  enum Suit s;		// C declaration of the same thing

Using typedef in C for an enum: