merge faq

Author: jsgoller1

faq/.gitignore

@@ -0,0 +1,53 @@
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
+bin/

faq/Makefile

@@ -0,0 +1,52 @@
+SHELL:=/bin/bash
+CC:= clang
+FLAGS := -std=c11 -g -Weverything -Werror
+VALGRIND := valgrind -q --leak-check=full --show-leak-kinds=all --track-origins=yes --error-exitcode=42
+
+### Dockerized Linux workspace for consistent environment
+docker-clean:
+	-docker stop ubuntu
+	-docker rm ubuntu
+
+docker: docker-clean
+	docker pull ubuntu
+	docker run \
+	-dt \
+	--name ubuntu \
+	-v `pwd`:/c-faq \
+	ubuntu
+	docker exec ubuntu apt-get update
+	docker exec ubuntu apt-get install -y make valgrind clang clang-tools cdecl perl
+
+shell:
+	docker exec -it ubuntu /bin/bash
+
+workspace: docker-clean docker shell
+
+clean:
+	-rm bin/*
+
+setup:
+	-mkdir bin
+
+# Chapter 5 examples
+arithmetic-ops-with-pointers \
+arrays-of-arrays \
+assign-to-assignment \
+fucking-for-loops \
+initialization \
+initializing-string-literals \
+long-lines \
+negative-integers \
+null-terminators \
+print-empty-arrays \
+printing-signed \
+returning-structs \
+single-quotes \
+strcmp \
+struct-alignment-bits \
+type-sizes \
+typedef-struct\
+unsigned-overflow: setup
+	$(CC) $(FLAGS) $@.c -o bin/$@
+	./bin/$@

faq/PHILOSOPHY.md

@@ -0,0 +1,20 @@
+# Unix Philosophy
+* Rule of Modularity: Write simple parts connected by clean interfaces.
+* Rule of Clarity: Clarity is better than cleverness.
+* Rule of Composition: Design programs to be connected to other programs.
+* Rule of Separation: Separate policy from mechanism; separate interfaces from engines.
+* Rule of Simplicity: Design for simplicity; add complexity only where you must.
+* Rule of Parsimony: Write a big program only when it is clear by demonstration that nothing else will do.
+* Rule of Transparency: Design for visibility to make inspection and debugging easier.
+* Rule of Robustness: Robustness is the child of transparency and simplicity.
+* Rule of Representation: Fold knowledge into data so program logic can be stupid and robust.
+* Rule of Least Surprise: In interface design, always do the least surprising thing.
+* Rule of Silence: When a program has nothing surprising to say, it should say nothing.
+* Rule of Repair: When you must fail, fail noisily and as soon as possible.
+* Rule of Economy: Programmer time is expensive; conserve it in preference to machine time.
+* Rule of Generation: Avoid hand-hacking; write programs to write programs when you can.
+* Rule of Optimization: Prototype before polishing. Get it working before you optimize it.
+* Rule of Diversity: Distrust all claims for “one true way”.
+* Rule of Extensibility: Design for the future, because it will be here sooner than you think.
+
+[Source](http://www.catb.org/esr/writings/taoup/html/ch01s06.html)

faq/README.md

@@ -0,0 +1,11 @@
+# c-faq
+This repo consists of questions I have had while learning C and experiments I've done to answer them. All FAQs here are strictly about C11; I make no claims about earlier versions of C.
+
+## Use
+All programs can be compiled and executed via the Makefile; just run `make <filename without the ".c" suffix>` and the program will compile and automatically execute.
+
+## TODO:
+- c11 / -Werror -Wall compliant
+- keywords descriptions
+- examples and experiments from "C Programming FAQs" by Steve Summit.
+

faq/arithmetic-ops-with-pointers.c

@@ -0,0 +1,53 @@
+#include <stdio.h>
+
+int main() {
+  /*
+  K&R say (p. 102, 2nd ed):
+  "...pointers may be compared under certain circumstances. If p and q point to
+  members of the same array, then relations like ==, 1=, <, >=, etc., work
+  properly. For example, p < q is true if p points to an earlier member of the
+  array than q does. Any pointer can be meaningfully compared for equality or
+  inequality with zero. But the behavior is undefined for arithmetic or
+  comparisons with pointers that do not point to members of the same array."
+
+  Let's confirm that!
+  */
+
+  long array1[5] = {0, 1, 2, 3, 4};
+  long array2[3] = {5, 6, 7};
+
+  long *ip1, *ip2;
+
+  // < is legal because the array is a contiguous block of bytes
+  ip1 = &array1[0];
+  ip2 = &array1[1];
+  printf("ip1, ip2: %p, %p\n", (void *)ip1, (void *)ip2);
+  printf("*ip1, *ip2: %ld, %ld\n", *ip1, *ip2);
+  printf("ip1 < ip2: %d\n", ip1 < ip2);
+
+  // < is undefined; we don't know where each thing is on the stack, and as
+  // such, we can't assume that array1 is above or below array2 address-wise.
+  ip2 = &array2[1];
+  printf("ip1, ip2: %p, %p\n", (void *)ip1, (void *)ip2);
+  printf("*ip1, *ip2: %ld, %ld\n", *ip1, *ip2);
+  printf("ip1 < ip2: %d\n", ip1 < ip2);
+
+  // if we subtract p1 from p2 below, do we get the number of elements in the
+  // array? Yes, make sure to add 1 as the last offset can store a value. This
+  // works regardless of types.
+  ip1 = &array1[0];
+  ip2 = &array1[4];
+  printf("ip2 - ip1: %ld\n", ip2 - ip1 + 1);
+
+  /*
+  Conclusion: pointer arithmetic is consistent; see K&R p. 103, 2nd ed:
+  "The valid pointer operations are assignment of pointers of the same type,
+  adding or subtracting a pointer and an integer, subtracting or comparing two
+  pointers to members of the same array, and assigning or comparing to zero. All
+  other pointer arithmetic is illegal. It is not legal to add two pointers, or
+  to multiply or divide or shift or mask them, or to add float or double to
+  them, or even, except for void *, to assign a pointer of one type to a pointer
+  of another type without a cast."
+  */
+  return 0;
+}

faq/arrays-of-arrays.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+// K&R exercises 5.8 and 5.9 discuss arrays of arrays, and arrays of pointers,
+// and the differences between each. Let's explore that some here.
+
+int main() {
+  // daytab is an array of pointers to arrays of chars; these could now
+  // be of different lengths as opposed to a "true" array of arrays
+  char *daytab[3];
+
+  // If we use an array of pointers, each thing pointed-to has to be initialized
+  // on its own
+  char non_leap_arr[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+  char leap_arr[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+
+  // Major advantage: arrays of pointers don't have to point to things of the
+  // same length!
+  char wtf_leap_arr[] = {0, 127, 127, 127};
+
+  daytab[0] = non_leap_arr;
+  daytab[1] = leap_arr;
+  daytab[2] = wtf_leap_arr;
+
+  printf("daytab: %p\n", (void *)daytab);
+  printf("daytab[0]: %p\n", (void *)daytab[0]);
+  printf("non_leap_arr: %p\n", (void *)non_leap_arr);
+  printf("non_leap_arr[1]: %d\n", non_leap_arr[1]);
+  printf("&non_leap_arr[1]: %p\n", (void *)&non_leap_arr[1]);
+  printf("non_leap_arr[2]: %d\n", non_leap_arr[2]);
+  printf("&non_leap_arr[2]: %p\n\n", (void *)&non_leap_arr[2]);
+}

faq/assign-to-assignment.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+// What happens if you assign to an assignment?
+
+int main() {
+  // In C, an assignment operation results in the rvalue.
+  int a, b, c, d;
+  a = (b = 200);
+  d = c = 100;
+  printf("%d %d\n", a, b);
+  printf("%d %d\n", d, c);
+  return 0;
+}

faq/fucking-for-loops.c

@@ -0,0 +1,48 @@
+#include <stdio.h>
+
+// How do I avoid off-by-one errors with for-loops?
+
+int main() {
+  int i;
+  int nums[5] = {0, 1, 2, 3, 4};
+
+  // nums is {0,1,2,3,4}, so the first char is arr[0] and the last one is
+  // arr[4], but len(arr) is 5. Generally, your options for going through arrays
+  // are:
+
+  // Option 1: start at zero, middle condition is "less than length", increment.
+  for (i = 0; i < 5; i++) {
+    printf("%d ", nums[i]);
+  }
+  printf("\n");
+
+  // Option 2: start at zero, middle condition is "less or equal to last index",
+  // increment.
+  for (i = 0; i <= 4; i++) {
+    printf("%d ", nums[i]);
+  }
+  printf("\n");
+
+  // Option 3: Go in reverse - start at the last element index, middle condition
+  // is "greater than or equal to zero", and decrement.
+  for (i = 4; i >= 0; i--) {
+    printf("%d ", nums[i]);
+  }
+  printf("\n");
+
+  // Anything else is off-by-one
+  // Common mistake #1 - middle condition is "less than or equal to length"
+  // for (i = 0; i <= 5; i++)
+  for (i = 0; i <= 5; i++) {
+    printf("%d ", nums[i]);
+  }
+  printf("\n");
+
+  // Common mistake #2 - while reverse-iterating, use "greater than zero"
+  for (i = 4; i > 0; i--) {
+    printf("%d ", nums[i]);
+  }
+  printf("\n");
+
+  return 0;
+}

faq/initialization.c

@@ -0,0 +1,40 @@
+#include <math.h>
+#include <stdio.h>
+
+/*
+K&R says (sect. 4.9) that static variables must be initialized with constants,
+but that automatic (i.e. variables with function scope) and register variables
+can be initialized with other types of expressions. Let's test that!
+*/
+
+int some_func(int z);
+
+/* x and y are declared, but not initialized */
+static int x;
+static int y;
+/*
+z and w are declared and initialized at the same time.
+Note that this won't compile if uncommented - z cannot be assigned to
+the return value of a function during compilation (how would
+that code run?).
+
+static int z = some_func(5);
+*/
+static int w = 10;
+
+int main() {
+  /* x is initialized with a constant. */
+  x = 5;
+  /*
+  y is assigned the return value of a function. Are K&R wrong?
+  No - this is acceptable at run-time; the only thing not-allowed
+  for static variables is non-constant initialization at compile time
+  (i.e. by declaring and initializing simultaneously.
+  */
+  y = some_func(x);
+  printf("%d\n", y);
+
+  return 0;
+}
+
+int some_func(int z) { return z * x; }

faq/initializing-string-literals.c

@@ -0,0 +1,35 @@
+#include <stdio.h>
+
+// What is the correct way in C to initialize a literal string?
+// https://softwareengineering.stackexchange.com/a/183862
+
+int main() {
+  /*
+  Suppose I want to declare the contents of a string at compile time.
+  I can use a string literal to do this.
+  */
+  char name[14] = {"JOSHUA GOLLER"};
+  char name2[] = {"Luke Skywalker"};
+  // Note that "JOSHUA GOLLER" has 13 characters, and
+  // so we initialize an array of 14 chars to include the \0.
+  // In the second case, the size of the array is taken from the initializer.
+
+  int i = 0;
+  for (i = 0; i < 13; i++) {
+    printf("%d, %c\n", name[i], name[i]);
+  }
+  printf("\n");
+
+  // Although the initializer will put a \0
+  // at the end of name2, this looping method
+  // is less safe; it's better to be explicit
+  // about the length of a string than not
+  // know but assume it's null terminated.
+  i = 0;
+  while (name2[i] != '\0') {
+    printf("%d, %c\n", name2[i], name2[i]);
+    i++;
+  }
+  printf("\n");
+  return 0;
+}