*A hello world example.*

The #include statement brings in the forward declaration for the printf function.

*Example of several different C features*

Video - https://youtu.be/uUtQIEIxvWY

This file goes over many of the features of C you will need to know, including data types, printf, structures, calling functions, and arrays.

*Getting user input in C using scanf.*

Note that scanf is not the best way to do it, but will suffice at first. The scanf function takes a pointer to a variable as its parameter so we need to pass the address (&) of the variable. We will go into more detail later in the course.

*Control structures in C such as loops, conditional statements, and controling loop execution.*

The syntax in this file should look familiar to you since, other than the input and output statements, almost every line of code is valid Java syntax. The scanf function gets input and stores it at the address given - the & operator gets the address of a variable. We will discuss that operator more when we discuss pointers.

*Examples of different data types built in to C and how we can work with them.*

Multiple examples of declaring and printing different data types. The variable declarations have multiple examples of different types of literals (a token that represents a fixed value). The printf statement allows you to include values in the output string through the use of control sequences. The control sequences are replaced by the expression(s) that follows the output string. Note that whatever expression you try to print will be implicitly converted to the type declared in the control sequence. That can cause confusion when you print a negative number using the %u control sequence, so if you get unexpected output always check that you are using the correct control sequence for the variable. Additional control sequences are listed in the C notes.

void print_num(int num);

int add_numbers(int a, int b);

struct simple_struct {

int num;

char name[10];

};

int main(void) {

int x = 10;

char c = 'K';

int nums[5];

int vals[] = {1,2,3,4};

struct simple_struct thing = {25, "Arizona"};

char hello[] = {'H', 'e', 'l', 'l', 'o', '\0'}; /* Null terminated */

char world[] = "world";

printf("Hello, world\n");

printf("x=%d, c=%c\n", x, c);

printf("x=%x, c=%d\n", x, c);

printf("hello=%s, sizeof hello = %lu\n", hello, sizeof(hello));

printf("world=%s, sizeof world = %lu\n", world, sizeof(world));

printf("thing: num=%d, name=%s\n", thing.num, thing.name);

thing.num = thing.num * 10;

thing.name[4] = 'X';

printf("thing: num=%d, name=%s\n", thing.num, thing.name);

thing.num = 2020;

/* thing.name = "Texas"; // You can't do this! */

strncpy(thing.name, "Texas", 6);

printf("thing: num=%d, name=%s\n", thing.num, thing.name);

print_num(add_numbers(thing.num, 6));

nums[0] = add_numbers(vals[2], 10);

print_num(nums[0]);

}

void print_num(int num) {

printf("The number is %d\n", num);

}

int add_numbers(int a, int b) {

return a + b;

}

#include <stdio.h>

int main (void)

{

int a = 5;

int b, ii;

printf ("Enter an integer : ");

scanf ("%d", &b);

printf ("\nIf-then-else statment : ");

if (a < b)

printf("%d is less than %d\n", a, b);

else

printf("%d is not less than %d\n", a, b);

printf ("\nSwitch statement : ");

switch (b)

{

case 1 :

printf("You entered a one.\n");

break; /* Without the break execution will continue to the next line */

case 2 :

printf("You entered a two.\n");

break;

case 3 :

printf("You entered a three.\n");

break;

case 4 :

printf("You entered a four\n");

break;

default : /* The default case is used when no other cases match */

printf("You entered a number greater than 4 or less than 1\n");

}

printf ("\nWhile loop : \n");

ii = 0;

while (ii <= b)

{

printf (" Your number = %d, loop variable = %d\n", b, ii);

ii = ii + 2;

}

/* The body of a do-while loop is always executed at least once */

printf ("\nDo-while loop : \n");

do {

printf (" Your number = %d, loop variable = %d\n", b, ii);

ii -= 2;

} while ( (ii > 0) );

/* Note: in C the loop variable must be declared before the loop */

printf ("\nFor loop : \n");

for (ii=0;ii<b;ii++) {

printf (" loop variable = %d\n", ii);

}

/* The break statement exists the current loop */

printf ("\nBreak example : \n");

for(;;) {

/* If a is bigger than 100 quit the loop */

if (a > 100) {

printf (" Breaking . . \n");

break;

}

else {

a++;

}

}

/* The continue statment skips the rest of the current iteration */

printf ("\nContinue example : \n");

for (ii=0;ii<=b;ii++) {

/* If ii is not a multiple of 3 then go to next loop iteration */

if ( (ii % 3) != 0) {

continue;

}

printf (" %d", ii);

}

printf ("\n");

return 0;

}

int main(void) {

int x = 59; /* Integer literal */

int y = 0x0A; /* Hexidecimal literal */

int z;

unsigned int a = -40; /* What happens here? */

char c = 'A'; /* Character literal */

char k = 66;

char s[] = "Hello!"; /* String literal */

float f = 10.0 / 3.0; /* Float literals */

/* To print variables in C, you use a control sequence to represent the

/* Examples of printf control sequences

printf("x = %d (%x hex)\n", x, x);

printf("y = %x (%d dec)\n", y, y);

printf("a = %u (%d int) (%x hex)\n", a, a, a);

printf("c = %c (%d int) (%x hex)\n", c, c, c);

printf("k = %c (%d int) (%x hex)\n", k, k, k);

printf("f = %f (%.2f formatted)\n", f, f);

printf("s= %s\n", s);

/* Note that z has not been initialized. What happens if we

/*

z = x + y;

printf("z = %d (%x hex)\n", z, z);

/* int vs char */

printf("\nHex: 100 - A = %d\n", 100-0xA);

printf("Char: 100 - A = %d\n", 100-'A');

for(z=0;z<26;z++) {

/* We can add an integer to a character literal */

printf("%c ", 'A' - z);

}

printf("\n");

return 0;

}

int main(void) {

printf("Hello, world!\n");

return 0;

}

int main(void) {

int b;

printf ("Enter an integer : ");

scanf ("%d", &b);

printf("Here is the integer you typed : %d \n", b);

return 0;

}

*Declaring and initialiing arrays. Array sizes. sizeof.*

The important thing to keep in mind about C arrays is that C does not perform any bounds checking. So you can use an index that is larger than the size of the array! What happens in that case? In C the size of the array is the number of bytes allocated for the array, not the number of elements in the array. So to determine the number of elements in an array you have to divide its size by the size of the type of the element it stores. One caveat to keep in mind - even the size of the array is lost when you pass the array to a function. So if you want to write a function that takes an array as a parameter you should include a length parameter as well.

*String handling in C. Initializing strings vs character arrays.*

C does not have a string type. Strings are represented using null-terminated character arrays. So if you have a valid string (character array) and you change the element where the null-terminator - '\0' - is stored then you no longer have a valid string. When you perform an operation on a string, including printf, the operation continues until a null-terminator is reached. This can be a problem if the string is not valid, so when writing functions that work on strings you should always include the length as a parameter.

*Defining & calling functions in C. Passing paremeters by pointer (reference). Forward declarations.*

In C, the compiler has to know the function signature before it is called in the code. One way to do this is to include a forward declaration, which is just the function signature followed by a semi-colon. In cases where the parameter is intended to be changed in the function we use pass-by-address: the parameter is preceded by * in the declaration (formal parameter) and when it is called (actual parameter) it is preceded by a &. If an array is passed as a parameter then the formal parameter does not need to include the length of the array as that is not passed to the function.

*Calling a function with an array pointer. Getting string input from user using fgets. Symbolic constants.*

We have to pass the length of the array to the function so the loop will know when to stop. The fgets() function has 3 parameters - the array you want to fill with the user input, the length of the array, and the file to read from. The identifier stdin refers to standard input (stdout is output and stderr is for errors).

*User-defined types in C, including enums, structs, and unions. typedef.*

*Size of structures with similar fields. Bitfields.*

int main(void) {

/* Initializing array declarations */

int a[4] = {1, 2, 3, 4};

double b[] = {2.4, 3.14, 9.9999}; /* b is the size of the initializer */

/* What happens if we declare an array with a size smaller than the initializer? */

unsigned int ii;

/* This is undefined behavior! */

for (ii=0;ii<6;ii++) {

printf("a[%d]=%d\t\tb[%d]=%.2f\n", ii, a[ii], ii, b[ii]);

}

printf("\n");

/* Are these sizes what you expect? */

printf("Size of int=%lu\n", sizeof(int));

printf("Size of a=%lu\n", sizeof(a));

printf("Size of double=%lu\n", sizeof(double));

printf("Size of b=%lu\n", sizeof(b));

printf("\n");

a[2] = 20;

a[3] = 200;

/* what does (sizeof(a)/sizeof(int)) do? */

for(ii=0;ii<(sizeof(a)/sizeof(int));ii++) {

printf("a[%d]=%d (%x)\n", ii, a[ii], a[ii]);

}

printf("\n");

return 0;

}

#include <stdio.h>

/* Symbolic constant */

#define LEN 100

int count_spaces(char[], int);

int main(void) {

char str[LEN];

printf("Enter a string: ");

fgets(str, LEN, stdin); /* Get a string from input, store it in str */

printf("Your string is: %s", str);

printf("Your string has %d spaces\n", count_spaces(str, LEN));

return 0;

}

int count_spaces(char str[], int len) {

int ii=0;

int count = 0;

/* The size of the string is unknown here, so we look for a null-terminator */

while ( (ii < len) && ( str[ii] != '\0') ) {

if (str[ii] == ' ') {

count ++;

}

ii++;

}

return count;

}