timtoday · September 26, 2017 08:45 · Mar 17, 2015 · Mar 17, 2015
diff --git a/functions.c b/functions.c
@@ -1,10 +1,13 @@
 /**
- * This is an introduction to fun function
- * usage in C.
- */
-
- /**
+ * This are a collection of examples for C 201.
+ * These combine concepts you may or may not be
+ * familiar with and are especially useful for
+ * students new to C. There is a lot of really
+ * cool stuff you can do in C without any cool
+ * languages.
  * 
+ * This is file in particular is an introduction
+ * to fun function usage in C.
  */
 
 #include <stdio.h>

diff --git a/functions.c b/functions.c
@@ -0,0 +1,64 @@
+/**
+ * This is an introduction to fun function
+ * usage in C.
+ */
+
+ /**
+ * 
+ */
+
+#include <stdio.h>
+
+int sum(int a, int b) {
+    return a + b;
+}
+
+int sub(int a, int b) {
+    return a - b;
+}
+
+// This function "get_operator" takes a *char expression
+// and returns a function that takes two ints and returns
+// an int.
+int (*get_operator(char* expression)) (int, int) {
+    int i;
+    // char pointers are automatically given a final character '\0'
+    // to allow us to know when the char* ends.
+    for (i = 0; expression[i] != '\0'; i++) {
+        switch (expression[i]) {
+            case '+':
+                return sum;
+            case '-':
+                return sub;
+        }
+    }
+}
+
+void print_operator(char* expression) {
+    // get_operator will return a function that takes two ints
+    // and returns an int.
+    int (*operator)(int, int) = get_operator(expression);
+    // sum is automatically converted to a pointer,
+    // you could also say "operator == &sum", but that is longer.
+    if (operator == sum) { // comparing functions!
+        printf("Expression %s is a sum.\n", expression);
+    } else if (operator == sub) { // comparing functions again!!
+        printf("Expression %s is a sub.\n", expression);
+    } else {
+        printf("Expression %s has an unknown operation.\n", expression);
+    }
+    // Challenge:
+    // Instead of just printing out which operation it is,
+    // find the two operands and perform the operation on them.
+    // Then print the result of the expression instead.
+}
+
+int main() {
+    char* expression1 = "2 + 2";
+    char* expression2 = "5 - 3";
+    char* expression3 = "9 * 7";
+
+    print_operator(expression1);
+    print_operator(expression2);
+    print_operator(expression3);
+}
diff --git a/functions2.c b/functions2.c
@@ -0,0 +1,65 @@
+/**
+ * This is an example of more complex function usage in C.
+ * Read structs.c before continuing.
+ */
+
+#include <stdio.h>
+
+// Good reference:
+// http://www.dirac.org/linux/programming/tutorials/function_pointers/
+
+typedef struct {
+    int legs;
+    void (*sayName)(void);
+} Animal;
+
+void catSayName() {
+    printf("I am a cat.\n");
+}
+
+void dogSayName() {
+    printf("I am a dog.\n");
+}
+
+int sub(int a, int b) {
+    return a - b;
+}
+
+int sum(int a, int b) {
+    return a + b;
+}
+
+double sum_d(double a, double b) { return a + b; } // would fail if passed to operate: operate(sum_d, 1, 2)
+
+int operate(int (*f)(int, int), int a, int b) {
+    return f(a, b);
+}
+
+void do_nothing(void) {
+    return;
+}
+
+int main() {
+    Animal cat;
+    cat.legs = 4;
+    cat.sayName = catSayName;
+
+    Animal cat1;
+    cat1.legs = 4;
+    cat1.sayName = catSayName;
+
+    Animal dog;
+    dog.legs = 3;
+    dog.sayName = dogSayName;
+
+    cat.sayName(); // I am a cat.
+    dog.sayName(); // I am a dog.
+    cat.sayLegs(cat.legs);
+
+    int my_sum = operate(sum, 1, 2);
+    printf("%d\n", my_sum); // Prints 3
+    int my_sub = operate(sub, 11, 2);
+    printf("%d\n", my_sub); // Prints 9
+
+    do_nothing();
+}
diff --git a/pointers.c b/pointers.c
@@ -0,0 +1,31 @@
+/**
+ * This is a collection of pointer examples.
+ * It is a fun way to test yourself. I'm
+ * sorry I couldn't think of a better way
+ * to show the answers.
+ */
+
+#include <stdio.h>
+
+void print(int i) {
+    printf("%d\n", i);
+}
+
+int main() {
+    int* myInt;
+    int myIntsValue = 3;
+    myInt = &myIntsValue; // int* somePointer; *somePointer = myIntsValue; myInt = somePointer;
+    print(*myInt); // prints 3
+    int mySecondInt = 2;
+    *myInt = mySecondInt;
+    print(*myInt); // prints 2
+    print(mySecondInt); // prints 2
+    print(myIntsValue); // prints 2
+    myInt = &mySecondInt; // int* somePointer; *somePointer = mySecondInt; myInt = somePointer;
+    mySecondInt = 5;
+    print(*myInt); // prints 5
+    myIntsValue = 7;
+    print(*myInt); // prints 5
+    mySecondInt = myIntsValue;
+    print(*myInt); // prints 7
+}
diff --git a/pointers2.c b/pointers2.c
@@ -0,0 +1,43 @@
+/**
+ * This is a continuation of (more complex)
+ * pointer examples.
+ */
+
+#include <stdio.h>
+
+void print(int i) {
+    printf("%d\n", i);
+}
+
+void swap1(int a, int b) {
+    int temp = b;
+    b = a;
+    a = temp;
+}
+
+void swap2(int* p_a, int* p_b) {
+    int temp = *p_b;
+    *p_b = *p_a;
+    *p_a = temp;
+}
+
+int main() {
+    int a = 1;
+    int b = 2;
+    swap1(a, b);
+    print(a); // prints 1
+    print(b); // prints 2
+    swap2(&a, &b);
+    print(a); // prints 2
+    print(b); // prints 1
+    int* c;
+    int* d;
+    c = &a; // c = some address... but *c = 2
+    d = &b; // d = some address... but *d = 1
+    swap1(*c, *d);
+    print(*c); // prints 2
+    print(*d); // prints 1
+    swap2(c, d);
+    print(*c); // prints 1
+    print(*d); // prints 2
+}
diff --git a/structs.c b/structs.c
@@ -0,0 +1,32 @@
+/**
+ * This is a brief example of typedef-ing and structs in C.
+ */
+
+typedef int Int; // int or Int
+
+struct Person {
+    char* name;
+    Int age;
+};
+
+typedef struct Person APerson; // struct Person or APerson
+
+typedef struct Animal {
+    int legs;
+} Animal; // struct Animal or Animal
+
+typedef struct {
+    int mpg;
+} Car; // cannot use struct Car, can only use Car... the struct is anonymous
+
+int main() {
+    APerson person; // could use "struct Person person"
+    person.name = "Phil";
+    person.age = 10;
+
+    Animal cat; // could use "struct Animal cat;"
+    cat.legs = 4;
+
+    Car car; // could not use "struct Car car;" because the struct was anonymous
+    car.mpg = 30;
+}