C Primer (Part 1)

Types are not known after the program is compiled, only the amount of bytes the variable takes up in memory.

You can also leave a variable undefined, without initializing the variable to an initial value. If you access the value of the variable before it is given a value, this behavior is undefined in C – you can get any random value!

short s;        // the variable is undefined
char ch = 'p';

short e = s;    // this is undefined behavior!
s = 4;          // the variable's value is changed to 4

The range of values that can be represented by each numerical type is dependent on the number of bytes allocated and whether or not the variable is signed or unsigned.

// x can go from 0 to 4,294,967,295
unsigned int x;
// y and z can go from -2,147,483,648 to 2,147,483,648
int y;
signed int z;

Note that the signed nature of y is implicit in the declaration of the variable (i.e. numbers are signed by default in C). These ranges fluctuate dependent on the type and whether or not decimals are supported.

In C, booleans are really just hidden integers. 0 is treated as false, while any non-zero integer is treated as true (typically represented by 1).

C passes arguments ‘by value’ to a function when it is called. For any variable passed to the function as an argument, a copy is made of its value in a different place in memory, which is then given to the function. Thus any changes to the argument in the function is not reflected in the variable passed in.

void changeVar(int n) {
    n = 3;
}

int main() {
    n = 10;
    changeVar(n);
    // n is still 10
}

The main function is the first function in your program that is executed, at program startup. There are two widely accepted signatures for main:

int main() {
    ...
}

int main(int argc, char* argv[]) {
    ...
}

These arguments are how command-line arguments, given when the program is run in terminal (see Compiling and Running your Code), are passed into the program. These arguments are given as an array to argv, with the first element being the name of C executable. (argv is an array of strings - see part 2 of this primer for more details). argc is the number of elements in argv - 1 more than the number of command-line arguments.

For example, if the C program test.c is compiled to the executable test, then we can run the program as ./test 3 I love CS 300!. The command line arguments are spaces separated - 3, I, love, CS, and 300!. Thus argc is 6 and argv is ["./test", "3", "I", "love", "CS", "300!"].

Each variable is accessible only in some portion of code, called its scope. You can typically think of a variable’s scope as starting where it is declared and ending at the next closing curly bracket }. Global variables are those defined outside any functions, and can be accessed and modified inside all functions. Local variables are those defined inside functions, and are only accessible within those said functions.

int a = 0;         // start of a's scope (global variable)

int main() {
    int b = 3;    // start of b's scope (local variable)
    a = 10;       // a can be accessed anywhere
    b = 2;
}                 // end of b's scope

void f(int x) {   // start of x's scope
    short c = 2;  // start of c's scope
    b--;          // here is outside of b's scope and
                  // this will cause a compilation error
    a = 3;        
}                 // end of c's and x's scope
                  // end of a's scope (end of file)

Scopes are also defined by if/else statements, and for and while loops. If two variables are in scope at the same time, the one with the inner-most scope supercedes the other.

int a = 0;

int main() {
    int b = 4;
    int c, d;
    
    for(int x = 1; x < b; x++) { // start of x's scope
        a += x;
    }                // end of x's scope
    
    {
        int b = 10;  // start of inner b's scope
        c = b;       // c is 10 (refers to inner b)
    }                // end of inner b's scope
    
    int d = b;       // d is 4, refers to outer b
}

Input and output operations in C are defined by C Standard Input and Output Library. This can be imported by including #include <stdio.h> at the top of your C file (refer to part 2 for more information on headers). The library includes the function printf:

#include <stdio.h>

int main(){ 
    printf("Hello World!\n"); 
    // printf tells your computer to print something to the console,
    // while the \n says to leave a line break afterwards
}

To print variables to the console, include a format specifier in the string to be printed, at the place where you want the variable to be. Then pass the variable as an additional argument to printf. All variables passed in addition to printf will replace the format specifiers in the string their given order.

The format specifier determines how to format the variable as a string, which includes:

• %d - formats the variable as a decimal (base 10) integer
• %c - formats the variable as an ASCII character
• %x - formats the variable as a hexidecimal (base 16) integer
• %p - formats the variable as a memory address (or pointer)
• %s - formats the variable as a string

#include <stdio.h>

int main() { 
    int numOfTAs = 18;
    short numOfHTAs = 4;
    char ch = 'A';
    
    // Declaring and initializing a pointer (more on this in Part 2!)
    int* pointer = &numOfHTAs;
    
    printf("There are %d TAs and %d HTAs, in CS300\n", numOfTAs, numOfHTAs);
    printf("My favorite letter is %c, whose ASCII code is %d.\n", ch, ch);
    printf("The pointer to a variable I wrote above is %p.\n", pointer);  
}

Example output:

There are 18 TAs and 4 HTAs, in CS300
My favorite letter is A, whose ASCII code is 65.
The pointer to a variable I wrote above is 0x7ffd1e2a375a. 

Programs written in the C lanuage are converted into executable files by programs called compilers. In this class, we use the GCC compiler (which stands for GNU Compiler Collection). To compile a C file, all you need to do is pass the file’s path as an argument into the gcc command. For example, for the file loops.c, we would enter the following in the bash terminal:

$ gcc loops.c

Barring any errors in compiling, this should produce an executable binary file called a.out. This is just the default name for a file that has been compiled. It is an abbreviated form of name “assembler output”, as the last stage of the compilation process.

To run an executable binary file, type a ./ followed by the name of the file, like so:

$ ./a.out

To give the compiler a target file name for the executable, you have to provide the -o flag followed by the target name:

$ gcc loops.c -o loops

This will create another executable binary named loops, which can be executed by:

$ ./loops