Learn C programming fundamentals like data types, control flow, functions, pointers, and memory allocation while exploring debugging, profiling, and optimization tools like GDB and gcc.

clang.tar.gz

RunC

RunCwithGNUflags

RunCwithlmflag

Run_go_file 

RunC-without_warning_flag

Compile-only

doNothing

Posix

RunCFileGo

Compile-go-file

Compile-go-debugging-file

OpenMP

Make

MPI4Threads

MPI8Threads

Octave

RunC-without_warning_flag-KS

This comprehensive course covers the fundamentals and advanced concepts of C programming to build a solid foundation for your programming journey. You’ll learn about essential topics like data types, variables, constants, and C statements, along with deeper explorations of control flow in C, including for loops and conditional statements in C. You’ll also learn about C functions, scope of variables, function arguments, and work with arrays, strings, and pointers in C.

You’ll gain hands-on experience with dynamic memory allocation, stack vs. heap, C standard library, and advanced topics such as binary files, input and output streams, and header files. The course also teaches compiling in C, linking in C, and debugging with tools like GNU debugger (GDB) and gprof for code profiling. By mastering these concepts, you’ll confidently program in C and optimize your code using gcc optimization flags.

Learn C

We understand how stack and heap work in theory. Now, let's internalize this by looking at concrete examples.

# A stack allocation example

Here is a short program that creates its variables on the stack. It looks like the other programs we have seen so far.

#include <stdio.h>

double multiplyByTwo(double input) {
  double twice = input * 2.0;
  return twice;
}

int main(void)
{
  int age = 30;
  double salary = 12345.67;
  double myList[3] = {1.2, 2.3, 3.4};

  printf("Your doubled salary is %.3f\n", multiplyByTwo(salary));

  return 0;
}

dockerforC.tar.gz

- On **lines 10**, **11** and **12**, we declare two variables of types `int` and `double`, as well as an array of three doubles. These three variables are pushed onto the stack as soon as the `main` function allocates each of them. 

- On **line 14**, When the `multiplyByTwo` function is called, it's parameter variable `input`, and the variable `twice`, which are both of type `double`, are pushed onto the stack as soon as the `multiplyByTwo` function allocates each of them.

- When the `multiplyByTwo` function exits, the variables in its scope are popped off the stack and are gone forever.

- As soon as the `main` function exits (and the program stops) the variables in its scope are also popped off the stack.  

> **Note:** The parameters of the `main` function, if any, are handled by the runtime environment and are not kept on the stack or the heap. 
    
# A heap allocation example

Here is another version of this program that allocates all of its variables on the heap instead of the stack:

Let's look at some  code and analyze how the allocations on stack and the heap take place. 

Code Examples

Let's look at some  code and analyze how the allocations on stack and the heap take place.

Introduction to C Programming

Data Types in C

C Operators and C Expressions

Control Flow in C

Functions in C

Complex Data Types

Stack vs. Heap

Pointers in C

C string

Input and Output Stream

Macros and the C Preprocessor

Header Files, Compiling and Linking

C Debugger

Code Profiling

Parallel Programming in C

Project: Using a Bootstrapped t-test

Conclusion

Miscellaneous

Appendix: Setting Up the Environment

Code Examples