cbootcamp.tar

cbootcamp/0000777000175000017500000000000013621415007012446 5ustar  xyshenxyshencbootcamp/casting.c0000777000175000017500000000122113617216263014251 0ustar  xyshenxyshen#include <stdio.h>
#include <stdint.h>

int main(void)
{
	uint16_t value = 0xFFFF;
	printf("Original Value: %u\n", value);
	printf("Unsigned 16->Signed 16: %hd\n", (int16_t)value);
	printf("Unsinged 16->Unsigned 32: %u\n", (unsigned int)value);
	printf("Unsigned 16->Unsigned 8: %hu\n", (uint8_t)value);
	printf("Unsigned 16->Signed 32: %d\n", (int)value);
	int16_t svalue = -1;
	printf("Original Value: %d\n", svalue);
	printf("Signed 16->Unsinged 16: %u\n", (uint16_t)svalue);
	printf("Signed 16->Signed 32: %d\n", (signed int)svalue);
	printf("Signed 16->Signed 8: %d\n", (uint8_t)svalue);
	printf("Signed 16->Unsigned 32: %u\n", (unsigned int)svalue);
}cbootcamp/Makefile0000777000175000017500000000110013621414715014106 0ustar  xyshenxyshenCC = gcc
CFLAGS = -g -Wall -Wextra -Werror -std=gnu99

all: passing_args pointer_arith mem_mgmt structs typedefs casting

structs:
	$(CC) -o structs structs.c 

typedefs:
	$(CC) -o typedefs typedefs.c 

casting: casting.c
	$(CC) $(CFLAGS) -o casting casting.c

passing_args: passing_args.c
	$(CC) $(CFLAGS) -o passing_args passing_args.c 

pointer_arith: pointer_arith.c
	$(CC) $(CFLAGS) -o pointer_arith pointer_arith.c 
	
mem_mgmt: mem_mgmt.c
	$(CC) $(CFLAGS) -o mem_mgmt mem_mgmt.c 

.PHONY: clean
clean:
	rm -f passing_args pointer_arith mem_mgmt structs typedefs casting
cbootcamp/mem_mgmt.c0000777000175000017500000000310113617216263014422 0ustar  xyshenxyshen/*
 * 15-213 C Bootcamp
 *
 * This program discusses memory management and proper freeing of memory 
 * allocated on the heap. Use in conjunction with the ./mem_valgrind.sh script
 * to check for memory leaks.
 *
 * Raghav Goyal (raghavgo)
 *
 */

#include <stdlib.h>
#include <stdio.h>

#define NUM_ARRS 4
#define BUF_SIZE 5

int main() 
{
    /* Typical malloc call:
     * TYPE *addr = malloc(NUM_ELEMS * sizeof(TYPE));
     * Take sizeof(TYPE) because we want the size of the data type that 
     * the returned address will point to.
     * Note that sizeof(TYPE) != sizeof(TYPE *) in most cases! 
     */

    // Allocate an array of pointers of size NUM_ARRS
    int *arr[NUM_ARRS];
    // Iterate through array and allocate an array of ints for each int pointer   
    for (int i = 0; i < NUM_ARRS; i++)
    {
        // Note the explicit cast to int *
        arr[i] = (int *)malloc(BUF_SIZE * sizeof(int)); 
        if (arr[i] == NULL)
        {
            printf("Malloc failed for arr[%d], aborting...", i);
            abort();
        }
        
    }
    // Suppress unused variable warning
    (void)arr;
    
    /* What is the correct way to free all allocated memory? 
     * Comment in the solution and check using valgrind!
     * Run ./mem_valgrind.sh in your terminal.
     */
    
    /*** A ***/
    /*
    for (int j = 0; j < NUM_ARRS; j++)
    {
        free(arr[j]);
    }
    */
    
    /*** B ***/
    /*
    for (int j = 0; j < NUM_ARRS; j++)
    {
        free(arr[i]);
    }
    free(arr);
    */
    
    /*** C ***/
    /*
    free(arr);
    */

    return 0;
}


cbootcamp/mem_valgrind.sh0000777000175000017500000000041113617216263015455 0ustar  xyshenxyshen#!/bin/bash
FILE=mem_mgmt

gcc --std=c99 -o $FILE $FILE.c

if [ -f $FILE ];
then
    echo "$FILE exists."
    echo "Running valgrind on ./$FILE..."
    valgrind --tool=memcheck --leak-check=full ./$FILE
else
   echo "File ./$FILE does not exist. Compile first"
fi

cbootcamp/passing_args.c0000777000175000017500000000334013617216263015305 0ustar  xyshenxyshen/*
 * 15-213 C Bootcamp
 *
 * This program demonstrates the difference between the call-by-value and 
 * call-by-reference principles.
 *
 * Raghav Goyal (raghavgo)
 *
 */
 
#include <stdlib.h>
#include <stdio.h>

/* Call-by-value
 * C is a call-by-value language. Changes made to arguments passed into a 
 * function are NOT seen by the calling function. 
 */
void test_val(int a, int b)
{
    printf("Test_val: before add, a = %d, b = %d\n", a, b);
    a = a + b; // Modify local variable
    printf("Test_val: after add, a = %d, b = %d\n", a, b);
}

/* Call-by-reference 
 * In this case, arguments are pointers to the memory locations in which 
 * variables used by the calling function are stored. Changes made by 
 * dereferencing these pointers directly modify memory and thus can be seen 
 * by the calling function.
 */
void test_ref(int *ptr_a, int *ptr_b)
{
    printf("Test_ref: before add, *ptr_a = %d, *ptr_b = %d\n", *ptr_a, *ptr_b);
    *ptr_a = *ptr_a + *ptr_b; // Directly modify memory
    printf("Test_ref: after add, *ptr_a = %d, *ptr_b = %d\n", *ptr_a, *ptr_b);
}

int main() 
{
    int a = 213;
    int b = 513;
    printf("Main: int a = %d, int b = %d\n\n", a, b);
    
    printf("Calling test_val(a, b)...\n");
    test_val(a, b);
    printf("Main: after test_val, a = %d, b = %d ... Did test_val do anything?\n\n", a, b);

    printf("Calling test_ref(&a, &b)...\n");
    test_ref(&a, &b);
    printf("Main: after test_ref, a = %d, b = %d ... Did test_ref do anything?\n", a, b);

    /* Lesson to learn: 
     * If you want to change the value of a variable, struct, etc., inside
     * another function, pass in POINTERS to those variables 
     * (call-by-reference) instead of the variables themselves
     */

    return 0;
}


cbootcamp/pointer_arith.c0000777000175000017500000000324413617216263015477 0ustar  xyshenxyshen/*
 * 15-213 C Bootcamp
 *
 * This program gives examples of casting and pointer arithmetic. 
 *
 * Raghav Goyal (raghavgo)
 *
 */

#include <stdlib.h>
#include <stdio.h>

#define BUFFER_SIZE 100

int main() 
{
    // Allocate a buffer
    char *A = malloc(BUFFER_SIZE);
    printf("A = %p\n", A);
 
    /* The following arithmetic examples are to show you how the ~type~ of 
     * the pointer affects arithmetic done on the pointer. 
     * When adding x to a pointer A (i.e. A + x), the result is really
     * (A + x * sizeof(TYPE_OF_PTR_A)).
     *
     * Remember to explicitly cast a pointer when doing arithmetic! 
     * Remember to put the sizes of different types on your midterm cheat sheet! 
     */
 
    /* char is 1 byte wide
     * B = A + (5 * 1) 
     *   = A + 0x5
     */
    char *B = (A + 5); 
    printf("B = (A + 5) = A + 0x5 = %p\n", B);

    /* short is 2 bytes wide
     * C = A + (2 * 2) 
     *   = A + 0x4
     */
    char *C = (char *)(((short *) A) + 2);
    printf("C = (((short *) A) + 2) = A + 0x4 = %p\n", C);

    /* int is 4 bytes wide, Char is 1 byte wide
     * D = (A + (3 * 4) + 7 * 1)
     *   = A + 19 
     *   = A + 0x13
     */
    char *D = ((char *)(((int *) A) + 3) + 7);
    printf("D = ((char *)(((int *) A) + 3) + 7) = A + 0x13 = %p\n", D);    

    /* int* and char*  (or any other pointer) is 8 bytes wide 
     * E = (((A + (2 * 8)) + 3 * 8) + 4 * 1)
     *   = A + 16 + 24 + 4
     *   = A + 44
     *   = A + 0x2C
     */
    char *E = ((char *)((int **)(((char **) A) + 2) + 3) + 4);
    printf("E = ((char *)((int **)(((char **) A) + 2) + 3) + 4) = A + 0x2C = %p\n", E);    
    
    // Clean up memory
    free(A);
    
    return 0;
}


cbootcamp/README0000777000175000017500000000030013617216263013332 0ustar  xyshenxyshenCode adapted from CMU 15213-f19 C BootCamp Handout:
https://www.cs.cmu.edu/afs/cs/academic/class/15213-f19/www/activities/cbootcamp/cbootcamp-s19.pdf
See the comments of each file for authors.cbootcamp/structs.c0000777000175000017500000000524613617216762014347 0ustar  xyshenxyshen// C Bootcamp Demo Deliverable: Structs
// jbiggs fall 2016
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>

#define LEN 4

// This is a definition of a struct. Things of type 'struct foo'
// will always have two longs in them: a long called bar, and a long
// called baz. Check out `main' to see how structs can be allocated.
struct foo {
    long bar;
    long baz;
};

// Structs can have different types in them, too.
struct superheroes {
    char *incredible;
    char *elastigirl;
    float frozone;
};

int main(int argc, char **argv)
{
    // declaring a struct on a stack is easy, but you can't return an
    // address to a struct when a function returns -- things get weird.
    struct foo stack_foo;
    stack_foo.bar = 3;
    stack_foo.baz = 4; // Always use "." for addressing a struct instance.

    // now a struct foo is allocated on the heap, so we have a *pointer* to
    // the struct. Accessing elements of a struct from a pointer is
    // slightly different.
    struct foo *heap_foo = malloc(sizeof(struct foo));
    heap_foo->bar = 5; // these arrows indicate that we are dereferencing
    heap_foo->baz = 6; // a struct pointer.

    // The size of struct foo and stack_foo should be the same, because
    // struct foo is the definition of the struct, and stack_foo is
    // an instance of the struct.
    printf("Size of struct foo: %lu\n", sizeof(struct foo));
    printf("Size of stack_foo: %lu\n", sizeof(stack_foo));
    // The size of heap_foo should be different, because it's a pointer
    // to a struct_foo.
    printf("Size of heap_foo: %lu\n", sizeof(heap_foo));

    // always remember to free what you malloc!
    free(heap_foo);

    struct superheroes *heroes_array = calloc(LEN, sizeof(struct superheroes));

    // Should be the same size as heap_foo, since these are both pointers.
    printf("Size of heroes_array: %lu\n", sizeof(heap_foo));
    // Careful: structs aren't always the combined size of their members!
    printf("Size of struct superheroes: %lu\n", sizeof(struct superheroes));

    // Note that heroes_array[0] is syntactic sugar for *(heroes_array + 0),
    // so we don't have to dereference the pointer again to access the field
    // of the struct. Basically, accessing an index in a struct array already
    // does the dereference for you. If we used an arrow here, the compiler
    // would complain.
    heroes_array[0].incredible = "Mr. Incredible!";
    heroes_array[0].elastigirl = "Elastigirl!";
    heroes_array[0].frozone    = 0.1137;

    // Remember: we don't need to free every field in the array, just the
    // pointer to the beginning of the array.
    free(heroes_array);
    return 0;
}
cbootcamp/typedefs.c0000777000175000017500000000166113617216263014454 0ustar  xyshenxyshen// C Bootcamp Demo Deliverable: Typedefs
// jbiggs fall 2016
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>

// typedef <thing you want to rename> <the name of the new thing>
typedef int number;

// of course, this gets weird when you throw in function pointers.
typedef number (*numberTransformer)(number);

number mul2(number x) {
    return x * 2;
}

int main(int argc, char** argv)
{
    // typedefs allow for code that is cleaner to read, as well
    // as increased modularity / polymorphism.
    number foo = 5;

    // numberTransformer is a type describing a function pointer
    // that takes in a 'number' type and returns another 'number' type.
    numberTransformer trans = &mul2;

    number bar = trans(foo);
    // For things like printf, treat the variable as its original type -- in
    // this case, treat it like an integer.
    printf("Bar is %d\n", bar);
    return 0;
}