Oh Crap, I Forgot (Or Never Learned) C! [CodeMash 2010]

Oh crap! I forgot (or
never learned) C!
Chris Adamson
CodeMash 2010

Objective- C is deﬁned as a small but powerful set of
extensions to the standard ANSI C language. […]
Objective-C is designed to give C full object- oriented
programming capabilities, and to do so in a simple and
straightforward way.

“Here, John Parker, take
this wheel. It drives just
like a truck.”

“Here, John Parker, take
this wheel. It drives just
like a truck.”

“Good. What is a truck?”

Don’t
Panic!
You can do this!

Libraries with C inside

Linux kernel (C, assembly), GNU libraries (C, C++)
OpenGL, OpenAL, SQLite, PostgreSQL, …
Way more than I can list here:
http://directory.fsf.org/category/clibs/

Languages that need C

Interpreters and VMs written in C:
Ruby, PHP, Perl, Java
Typically, you’ll use C to call into native libraries from these
languages (e.g., Java Native Interface)

Even on iPhone

Some essential iPhone libraries are C-only:
OpenGL, OpenAL
Core Audio, Core Graphics, Core Foundation
Keychain, Address Book, System Conﬁguration

C’s descendents

Languages inspired by C or directly based on it are the
dominant languages for systems, application, and mobile
development:
C++, Objective-C, Java, C# [?]
Can we call these the *C* languages?

C’s traits

Minimal: no ﬂuff!
Portable: nearly every OS has a C compiler
Performant!

C performance

http://gmarceau.qc.ca/blog/2009/05/speed-size-and-
dependability-of.html

Is C a high-level
language?

CPU abstraction

int x = 5;
int y = 10;
int z = x + y;

CPU abstraction

.loc 1 38 0
movl $5, -12(%ebp)
.loc 1 39 0
int x = 5; movl $10, -16(%ebp)
int y = 10; .loc 1 40 0
int z = x + y; movl -16(%ebp), %eax
addl -12(%ebp), %eax
movl %eax, -20(%ebp)

Intel x86

CPU abstraction

add r0, sp, #24
add r3, sp, #16
int x = 5; add r2, sp, #20
ldr r1, [r3]
int y = 10; ldr r3, [r2]
int z = x + y; add r3, r1, r3
str r3, [r0]

ARM

Memory abstraction

Memory may be dynamically allocated and freed
malloc(), free()
No garbage collection or other automated memory
management techniques
Libraries and later languages add this

“High” or “Low” level

Old CW: Abstracting away the CPU makes you high-level
Effectively, anything other than assembly was high-level
New CW: Abstracting away the memory makes you high-level
C in 2010 is what assembly was in 1980

So why should I learn C?

Pro: You may have to use it for something
Embedded systems, native code calls, highly portable
Con: You probably won’t be as productive
Lower abstraction cost implies lower abstraction value

How do you (re-)learn C?
C is rarely anyone’s ﬁrst language
I learned a variety of BASICs, Pascal, and assembly ﬁrst
If you’re at CodeMash, you likely know one or more C-
inspired languages
Direct descendants: C++, Java, csh
Distant relatives: Python, Ruby, other shells

Smoke ‘em if you got ‘em
Your language probably has traits in common with C
Control structures, parameters and return values, etc.
Your language probably added stuff that C doesn’t have
Objects
Garbage Collection
Closures, type-safety, generics, …

The absolute basics

C source is compiled directly into a machine-executable
binary
As far as the compiler cares, your C program could be one
big listing
Execution starts inside the main() function

Headers and includes

By convention, we use separate header and source ﬁles
Header (.h) includes public information: function names,
constants, and other stuff needed by callers
Source (.c, .cpp, .m, .mm) includes implementation code
Use #include to include header when compiling

“Hello World” in C

#include <stdio.h>

int main() {

printf ("Hello world!");

}

C expressions

Expression is a combination of operators and operands
x + 1 has one operator (+) and two operands (x, 1)
Mathematical operators: +, -, *, /, %, >>, <<, >>>
Logical operators: !, &, |, &&, ||, <, >, <=, >=, !=, ?:
Use parentheses for ordering: a+b*c vs (a+b)*c

C types
Integer types: short, int, long, long long
int and long may be “unsigned”
Floating-point types: ﬂoat, double
Other types: char, bool
Absence of type: void
Bit depth of numeric types is undeﬁned

Type conversion
Expressions that combine types implicitly change them
char, short convert to int
ﬂoats convert to double
ints convert to long
unsigned becomes signed
all other cases: everything’s an int

Assignment
Declare a variable of a type, then assign its value as the
result of an expression

int x;
x = 3;

x = x + 1
x += 1;
x++;

Assignment from functions
Can also use a function call to assign a value
Can combine these

int x;
x = abs (rand() % 5);

Creating a function
Declare return type, name, parameter types and names

double circumference (double r) {
return 2 * 3.14159 * r;
}

Variable scope
C variables use lexical scope: only available within the
function in which they’re declared
Variables with same name in different scope are different
variables
Variables declared outside the scope of any function are
“global variables”, and are available anywhere
Try not to use them much, if at all

Pass by value
What is the value of y?

int addOne (int x) {
return x+1;
}

int y = 0;
int z = addOne (y);

Pass by value
What is the value of y?

int addOne (int x) {
return x+1;
}

int y = 0;
int z = addOne (y);

y is still 0. The function gets y’s value (0), not the y
variable itself

Flow Control: if-else
if (expression)
// execute statement if true
else
// execute statement if false

“true” means “non-zero”
Executes only one statement for each branch; use curly-
braces to do more

Flow-control: switch
switch (expression) {
case value1:
// statements
break;
case value2:
// statements
break;
// other cases
default:
// statements execute in any case
}

Flow-control: while

while (expression)
// statement

do
// statement
while (expression);

Flow-control: for

for (initExpression;
continueExpression;
countingExpression)
// statement

Flow-control: break

break terminates innermost for, while, do, or switch
return exits from a function, with a value if function declares
one
goto jumps to a labelled line of code
“Go To statement considered harmful”, 1968

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

A list of constant int values
Starts at 0 and increments, unless you assign speciﬁc values
with =
Alternative: use #deﬁne preprocessor directive

#define HEARTS 1
#define DIAMONDS 2

New types: typedef

Allows you to deﬁne new type names for variables
By convention, typedef names are capitalized

typedef enum {HEARTS, DIAMONDS, CLUBS, SPADES} SuitType;

int main() {
SuitType suit = DIAMONDS;
}

Structs

Creates “structure” consisting of several named members of
various types
Access members with dot operator
Really tempting to call it an “object”, but…

Structs aren’t objects

struct CGPoint {
CGFloat x;
CGFloat y;
};
typedef struct CGPoint CGPoint;

void addToPointX (CGPoint aPoint) {
aPoint.x += 10;
}

aPoint.x += 10;
}

CGPoint point;
point.x=0;
point.y=0;
addToPointX (point);

aPoint.x += 10;
}

CGPoint point;
point.x=0;
point.y=0;
addToPointX (point);

point.x is still 0, because the whole CGPoint is a value,
not an object

Arrays
Indexed access to multiple instances of a type
Declare with [] and size of array
Access an index with [index]
First member is index=0

Card deck[52];
Card topCard = deck[0];

Character arrays / strings
An array of type char is a string
Terminated by a null character (/0)
Can declare literals with “” operator
Conveys no information about encoding, typically assumed
to be ASCII

char confName[] = "CodeMash";

This is where it gets
scary

Arrays are syntactic sugar

Array is just a reference to a location in memory
Index is an offset
No bounds checking!

Pointers
A pointer is literally a memory address, interpreted as a
reference to a variable at that memory address
Indicated with the * character

Pointers

char confName[] = "CodeMash";

Pointers

char *confName = "CodeMash";

Using pointers
A pointer to a variable is used like any other variable of that
type
Access to members of a pointed-to struct use the -> operator
A function that takes a pointer parameter or returns a
pointer declares * on the type
To refer to the address of a pointer, use &

Pointer example
void reallyAddToPointX (CGPoint *aPoint) {
aPoint->x += 10;
}

Pointer example
aPoint->x += 10;
}

CGPoint point;
point.x=0;
point.y=0;
reallyAddToPointX (&point);

Pointer example
aPoint->x += 10;
}

CGPoint point;
point.x=0;
point.y=0;

point.x is now 10.0

Allocating memory

Allocate memory with malloc()
The amount you need can be determined with sizeof()
Return value is a pointer to allocated memory
Release memory with free()

malloc() example
CGPoint point;
point.x=0;
point.y=0;

malloc() example
CGPoint point;
point.x=0;
point.y=0;

CGPoint *point = malloc(sizeof(CGPoint));
point->x=0;
point->y=0;
reallyAddToPointX (point);

malloc() example
CGPoint point;
point.x=0;
point.y=0;

CGPoint *point = malloc(sizeof(CGPoint));
point->x=0;
point->y=0;
reallyAddToPointX (point);
free (point);

How to crash instantly

Use a bogus address in a pointer
CGPoint *point = 42;
point->x = 0;

How to crash instantly

Use a bogus address in a pointer
CGPoint *point = 42;
point->x = 0;
Exception Type: EXC_BAD_ACCESS (SIGBUS)
Exception Codes: KERN_PROTECTION_FAILURE at 0x000000000000002a
Crashed Thread: 0 Dispatch queue: com.apple.main-thread

Application Specific Information:
iPhone Simulator 3.1 (139.1), iPhone OS 3.1.2 (7D11)

Thread 0 Crashed: Dispatch queue: com.apple.main-thread
0 CGPointCheck 0x00002854 -[CGPointCheckViewController
viewDidLoad] + 72 (CGPointCheckViewController.m:53)

More memory functions

Copy blocks of memory with memcpy()
Set a block of memory with memset()
Often used to “zero out” a buffer

Address arithmetic
Some memory functions require you to compute memory
locations manually
Assume array a of type t
Index n is at a + (n * sizeof(t))

Address arithmetic
Some memory functions require you to compute memory
locations manually
Assume array a of type t
Index n is at a + (n * sizeof(t))

memcpy(ioData->mBuffers[currentBuffer].mData +
(currentFrame * 4) + (currentChannel*2),
&sample,
sizeof(AudioSampleType));

I/O parameters
C’s version of multiple return values
You pass in a pointer, it gets populated when function
returns
OSStatus AudioUnitGetProperty (
AudioUnit inUnit,
AudioUnitPropertyID inID,
AudioUnitScope inScope,
AudioUnitElement inElement,
void *outData,
UInt32 *ioDataSize
);

Things to take away
C is still popular for good reasons
C’s performance and portability are building blocks for
languages and libraries
Lingua franca: everybody used to know it. Maybe
everyone still should.
Thinking about memory can be a good thing!

When you have questions

Kernighan & Ritchie, The C Programming
Language, Prentice-Hall, 1988 (yes, really)
comp.lang.c
stackoverﬂow.com
Sample code!

Or just bug me

Web: http://www.subfurther.com
Blog: http://www.subfurther.com/blog
E-mail: invalidname@gmail.com
Twitter: @invalidname

Oh Crap, I Forgot (Or Never Learned) C! [CodeMash 2010]

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Oh Crap, I Forgot (Or Never Learned) C! [CodeMash 2010]

Similar to Oh Crap, I Forgot (Or Never Learned) C! [CodeMash 2010] (20)

More from Chris Adamson

More from Chris Adamson (20)

Recently uploaded

Recently uploaded (20)

Oh Crap, I Forgot (Or Never Learned) C! [CodeMash 2010]