Some. Got the basics for C++. More later...

Author: Cory Frontin

.gitignore

@@ -0,0 +1,3 @@
+
+syntax
+

syntax.cpp

@@ -0,0 +1,171 @@
+
+// this is a .cpp file, which is just a file for C++ source code
+
+// header: functions, classes, and objects included from either from connected
+// programs, or declared in a separate file for convenience
+#include <stdio.h>          // this is needed for output to terminal ("printf")
+#include "syntax.h"
+
+// this is a syntactical program for C++, which should stand as a standalone
+// cheatsheet for programming in C++ for experienced programmers
+int main() {
+
+  // prints output to screen
+  printf("Hello, world!\n\n");
+
+  // FUNDAMENTAL VARIABLE TYPES
+
+  bool boolean= false;              // this type will store true or false values
+
+  char character_letter= 'a';       // this type will store either a "character"
+  char character_number= 48;        // or an integer of most efficient size
+  unsigned char character_unsigned= 21;     // it can be either signed
+  signed char character_signed= -21;        // or unsigned
+
+  int integer= 2;                   // this type will store a 2+ byte integer
+  // this can also have both signed and unsigned variants
+  short int integer_short= 1000;    // short is guaranteed to have 2 bytes
+  long int integer_long= 100000;    // long is guaranteed to have 4 bytes
+  // long long also possible for 64 bit integers!
+
+  float floatingpoint_single= 0.5;  // this type is a single-precision "decimal"
+  double floatingpoint_double= 0.25;// this type is a double-precision "decimal"
+  // long double is also possible!
+
+  // there is also a "void type", which is a type with an empty set of values.
+  // it is an "incomplete type" and cannot be completed- so void objects are not
+  // allowed. no void arrays, no void references. pointers to void and functions
+  // that return void are allowed, and quite useful!
+
+  // ARRAYS
+
+  // an array is an object that consists of N contiguously allocated objects of
+  // a given type T. below, we take T to be double, but double could easily be
+  // replaced below with any of the fundamental variables types (excl. void),
+  // pointers, pointers to memebers, classes, enumerations, etc.
+  int N= 5;
+
+  double array[N];
+
+  double array_onconstruction[N]= {1.0, 0.5, 0.25, 0.125, 0.0625};
+
+  // CONTROL STATEMENTS
+
+  // if statement
+  bool should_do= true;
+  bool otherwise_todo= true;
+  if (!should_do) {
+    printf("I should not have done this.\n\n");
+  } else if(otherwise_todo) {
+    printf("If I should do this thing only if I didn't do the "
+        "first and you also told me to do this one as well.\n\n");
+  }
+  else {
+    printf("I only do this if I didn't do any of the other things.\n\n");
+  }
+
+  // for statement does something:
+  //    for(some variable, initialized; while some condition holds;
+  //    changing some variable at the end of each iteration)
+  for (int k= 0; k < N; k++) {
+    printf("%f\t", array_onconstruction[k]);
+  }
+  printf("\n\n");
+
+  // while statement does something while a statement is true
+  int counter= 2;
+  while (counter < 1000) {
+    counter= counter*counter;
+    printf("%d, ", counter);
+  }
+  printf("\n\n");
+
+  // switch/case statements take some condition
+  int switch_variable= 2;
+  switch (switch_variable) {
+    case 1:     // jumps here if switch_variable == 1 and continues til break
+      printf("ah yes. ");
+      break;    // leaves switch/case statment
+    case 2:     // jumps here if switch_variable == 2 and continues
+      printf("oh, no! ");
+    case 3:     // jumps here if switch_variable == 3 and continues
+      printf("nope. nope. nope. ");
+    default:    // runs if it gets here
+      printf("this is very bad indeed.\n\n");
+  }
+  // note that, in the absence of break statements, switch/case will continue to
+  // run through all of the options
+
+  // CLASSES
+
+  // we can declare a class here, which is defined in the header file
+  aClass cls= aClass();
+  // you can interact with the public members of a class, but not private ones
+  int x_cls= 4;
+  double c_cls= 5.2;
+
+  cls.setX(x_cls);
+  cls.zEqualsProduct(c_cls);
+  printf("z= %f.\n", cls.getZ());
+
+  // each instance of a class has a separate set of variables so we can
+  // instantiate a second and see a completely secondary result!
+  aClass cls2= aClass();
+  int x_cls2= 8;
+  double c_cls2= 1.703333;
+  cls2.setX(x_cls2);
+  cls2.zEqualsProduct(c_cls2);
+  printf("z= %f.\tz2= %f!\n\n", cls.getZ(), cls2.getZ());
+
+  // the next thing you can do is derive classes. we have in the header file a
+  // sample class that holds two values and can perform an operation on them.
+  // class derivation allows us to use the same "base class"
+
+  operation op= operation();
+  summer smr= summer();
+  multiplier mlt= multiplier();
+
+  printf("summer gives: %f\nmultiplier gives: %f\n\n",
+      smr.getSum(), mlt.getProd());
+
+  // typedefs are aliases that can be used anywhere in place of type names,
+  // which can frequently get annoyingly complex; they're also useful when the
+  // type of something is passed as an input enum, for example. we create a
+  // typedef for an unsigned int here:
+  typedef unsigned int unsgn;
+
+  // now we can create an unsigned int this way:
+  unsgn xTD= 5;
+
+  printf("%d\n\n", xTD);
+
+  // function pointers are particularly useful too.
+  // let's make a function in the header file
+
+  // we create a typedef for integer-returning function pointers with
+  // one parameter of type character with:
+  typedef int (* funcptr)(double);
+
+  // now we create a function pointer!!!
+  funcptr fpt= function;      // note that CPP compilers will implicitly convert
+                              // function names to function pointers!
+
+  // now call function via the pointer!
+  double pi= 3.1415926535;
+  printf("%f is approximated by %d.\n\n", pi, (*fpt)(pi));
+
+  // last but not least, we can use class templates to build generic classes. in
+  // the header file, we make a template to find y= m*x + b, regardless of the
+  // type that is used for x, y, m, and b.
+  line<double> pointslopedouble= line<double>(2*pi, 1.0);
+  line<int> pointslopeinteger= line<int>(2*pi, 1.0);
+
+  printf("(x, y)= (%f, %f)\n", 1.0, pointslopedouble.compute(1.0));
+  printf("(x, y)= (%d, %d)\n", 1, pointslopeinteger.compute(1.0));
+
+  // every function has to return something unless it is a void function
+  // this function returns an integer and standard practice for a main is to
+  // return zero if everything went to plan
+  return 0;
+
+}

syntax.h

@@ -0,0 +1,89 @@
+
+// this declares a class
+class aClass {
+private:	// private members are only accessible by other members of this class
+  int x;
+  double z;
+public:   // public members are globally accessible!
+  void zEqualsProduct(double c) {
+    z= c*x;
+  }
+  double getZ() {
+    return z;
+  }
+  void setX(int xIn) {
+    x= xIn;
+  }
+};
+
+// this declares a base class
+class operation {
+private:		// private members can't be accessed by derived classes
+	void print() {
+		printf("this does an operation f(x, y), where f and x are doubles.\n\n");
+	}
+protected:	// protected members, are only accessible from other members of this
+						// class OR by members of derived classes!
+	double x;
+	double y;
+public:
+	operation() {
+		x= 0;
+		y= 0;
+	}
+	operation(double xi, double yi) {
+		x= xi;
+		y= yi;
+	}
+};
+
+// this declares a derived class
+class summer : public operation {
+public:
+	// while we are here, we'll also go ahead and do a default constructor here.
+	summer() {
+		x= 1;
+		y= 2;
+	}
+	double getSum() {
+		return x*y;
+	}
+};
+
+// we can derive a multiplication class from operation, like addition, such that
+class multiplier : public operation {
+public:
+	multiplier() {
+		x= 3;
+		y= 4;
+	}
+	double getProd() {
+		return x*y;
+	}
+};
+
+// let's make a function that converts doubles to ints
+int function(double x) {
+	return (int) x;
+};
+
+// let's make a function that computes y= m*x + b where each of x, y, m, and b
+// aren't of a defined type, but of a type to be later determined...
+template <typename T>
+class line {
+private:
+	T m;
+	T b;
+public:
+	line() {
+		m= 1;
+		b= 1;
+	}
+	line(T mIn, T bIn) {
+		m= mIn;
+		b= bIn;
+	}
+	T compute(T x) {
+		return m*x + b;
+	}
+};