C Programming Refresh¶

The high-level programming language C is used to program MCUs. Generally, the programmer of this kit is expected to be familiar with the C programming language. Read here for more about the language skill level needed to implement the kit.

Keywords¶

The C programming language has several keywords hat can be used to implement the desired functionality. A list of all keywords, including a short description, can be found at cppreference.com or you can look into the C Reference Card.

Data Types and Size¶

Each variable in C has an associated data type. It specifies the type of data the variable can store, such as integer, character, floating point number, etc. Therefore, the data type gives the notion of memory size and how the data is encoded in the memory.

Base Data Types¶

The standard C data types are int, char, float and double.

The integer type – int¶

int type stores data as “whole numbers”. An integer is typically the size of a machine word. This size depends on your system architecture. It is 32 bits (four bytes) for the most modern computers. A basic integer can store a number between \(-2^{N-1}\) to \(2^{N-1}-1\), where N is the bit number of the integer memory size.

The basic principle is used to create and initialise an integer variable.

int myInitialisedInt = 17;
int myUninitialisedInt;

The encoding of the data can be modified by the following keywords, which change the integer range:

• unsigned:

  With the keyword unsigned, the range of an integer is modified to represent only positive numbers. This results in doubling the range for positive numbers compared to the signed range. Generally, an unsigned is followed by the datatype and name, which will be interpreted as an unsigned variable. Using only the unsigned keyword without a specific datatype will correspond to an unsigned int.

  Example

  unsigned int myUnsignedInt = 10;
  unsigned mySecondUnsignedInt = 20;
  

• short and long:

  These keywords are modifiers for the size of an integer, but they also depend on the underlying hardware—the system. So, it is not guaranteed that a short is always smaller than an int and a long is always larger than an int. The rule which is guaranteed is that sizeof(short) <= sizeof(int) <= sizeof(long). Some compiler accepts the datatype long long which follows the rule sizeof(long) <= sizeof(long long).

  The mentioned keywords can also be combined with the unsigned keyword.

  Example

  unsigned short myUnsignedShort;
  short myShort = -42;
  long myLong = 1000000;
  long long myLongLong;
  

• char:

  A char is the abbreviation for character. It stores the same kind of data as an int, but has typically a size of 1 byte. The total number of bits stored in a char is stored in the macro CHAR_BIT. A char is mostly used to store characters, hence its name. Most implementations use the ASCII character set as the execution character set, but it’s best not to know or care about that unless the actual values are important.

  Basic characters are 'a', 'B', '1', ',' and some special characters like '\n' (newline or LF-Linefeed), '\t' (horizontal tab) or '\0' (Null or end-token).

  Important

  It is important to use the single apostrophes ‘ like 'A' to declare it as a character. The double apostrophes “ are used to declare a c-character array like "This is a C-String". Read more about this topic in the section Characters and C-Strings.

  The characters are represented with a decimal number, e.g. the character 'A' is represented with the decimal number 65. For initialisation, both values are accepted. It is recommended to use the characters for a higher readability than using the decimal or hexadecimal values.

  Example

  char myA = 'A';
  char mySecondA = 65; // Results in character 'A'.
  

Floating Point Numbers¶

• float:

  A float is the abbreviation for floating point. It can stores real numbers in an defined precision. float use the single-precision format of a floating point number. The size is typically one machine word.

  A floating point number can be initialised with floating literals which use a f or F as suffix. Additional to a decimal notation, the scientific notation can also be used.

  Example

  float myFloat = 0.0011f;
  float myScientificFloat = 1.1e-3f;
  

• double:

  The double and float data types are very similar. Instead of using the single-precision format from float, double use, as the name suggests, double-precision format. The size is typically two machine words.

  The distinction between floats and doubles was made because of the different sizes of the two types. When C was first used, space was at a minimum and so the judicious use of a float instead of a double saved some memory. Nowadays, with a lot free memory available, this problem is removed. Sometimes, some C implementations use doubles instead of floats when you declare a float variable.

  The initialisation is the same as for a float, except using the double keyword instead of the float.

  Example

  double myFloat = 0.0011f;
  double myScientificFloat = 1.1e-3f;
  

/**
 * @file sizeof.c
 * @ref BTS1230
 * @ref MCU Programming
 * @copyright Bern University of Applied Sciences, 2021. All rights reserved.
 *
 * @author Pascal Mainini <pascal.mainini@bfh.ch>
 * @author Adrian STEINER <adrian.steiner@bfh.ch>
 * @date 20.09.2021
 * @date 17.10.2024
 *
 * @brief Print memory size and range for different data types.
 *
 * This program prints the actual space used in memory by different data types
 * using the sizeof-operator.
 *
 * Compile it using:
 * gcc -std=c17 -Wall -Wextra -Wpedantic -O3 -o sizeof sizeof.c
 *
 * Run it using:
 * ./sizeof
 */

#include <stdio.h>
#include <limits.h>
#include <float.h>
#include <stdint.h>

#define EMPTY_LINE (puts(""))

int main(void) {   
  
  printf("A  char is               %2zu bytes and has a range of %20d to %20d\n", sizeof(char), CHAR_MIN, CHAR_MAX);
  printf("A  short is              %2zu bytes and has a range of %20d to %20d\n", sizeof(short), SHRT_MIN, SHRT_MAX);
  printf("An int is                %2zu bytes and has a range of %20d to %20d\n", sizeof(int), INT_MIN, INT_MAX);
  printf("A  long is               %2zu bytes and has a range of %20ld to %20ld\n", sizeof(long), LONG_MIN, LONG_MAX);
  printf("A  long long is          %2zu bytes and has a range of %20lld to %20lld\n", sizeof(long long), LLONG_MIN, LLONG_MAX);
  EMPTY_LINE;
  printf("An unsigned char is      %2zu bytes and has a range of %d to %21u\n", sizeof(unsigned char), 0, UCHAR_MAX);
  printf("An unsigned short is     %2zu bytes and has a range of %d to %21u\n", sizeof(unsigned short), 0, USHRT_MAX);
  printf("An unsigned int is       %2zu bytes and has a range of %d to %21u\n", sizeof(unsigned int), 0, UINT_MAX);
  printf("An unsigned long is      %2zu bytes and has a range of %d to %21lu\n", sizeof(unsigned long), 0, ULONG_MAX);
  printf("An unsigned long long is %2zu bytes and has a range of %d to %21llu\n", sizeof(unsigned long long), 0, ULLONG_MAX);
  EMPTY_LINE;
  printf("A float is               %2zu bytes and has a range of %.5g   to %.5g\n", sizeof(float), FLT_MIN, FLT_MAX);
  printf("A double is              %2zu bytes and has a range of %.5g  to %.5g\n", sizeof(double), DBL_MIN, DBL_MAX);
  printf("A long double is         %2zu bytes and has a range of %.5Lg to %.5Lg\n", sizeof(long double), LDBL_MIN, LDBL_MAX);
  
  return 0;
}

Defined sized Data Types¶

By including the header file #include <stdint.h> or #include <inttypes.h>, standardised integers with a exact size are defined. This has the advantage of being able to use variables with a defined size independently of the system. This is useful if you write a module for your computer and for your MCU. In MCU programming, it is used to write to registers with a defined size to manipulate all the desired bits, but not to overwrite more. The basic defined sizes of the variables are:

Data Types Quiz¶

Pointers¶

Pointers are one of the core components in the programming language C. The concept of pointers offers a new handling of memory which results in the most cases of less required memory, unnecessary memory copies and faster access.

Definition¶

All used variables are stored in the memory at a specific address. This address can be stored in a pointer variable. The pointer can now be dereferenced and the data at this address can be modified.

The advantage of this system is that the pointer variable size depends on the system architecture and is the same for all pointers types. They are independent of the size of the referenced variable.

Demo

Handling¶

The pointer includes new functionalities to work with variables. As it is recommend to initialise a pointer immediately at the declaration, we combine this two steps together.

1. Pointer declaration and initialisation

   To get the address of a variable, the address of operator & is used.

   Template Example

   <type> *<prtName> = <initAddress>;
   

   int myInt = 0;
   int *myIntPtr = &myInt;
   

2. Pointer address access

   To access to the stored address, no additional operator is needed.

   Template Example

   printf("The stored address is %p"/*(1)!*/, thePointer/*(2)!*/);
   

   1. Tip

      %p is used to display pointers.

   2. Tip

      The pointer can be of any datatype. The address will always have the same size.

   int base = 10;
   int *thePointer = &base;
   printf("The address of base is %p", thePointer);
   

3. Pointer dereferencing

   To get access to the value in the stored address, the dereference operator * is used.

   Template Example

   printf("The value of thePointer's address is %d", *thePointer);
   

   int base = 10;
   int *thePointer = &base;
   printf("The value of base is %d", *thePointer);
   

Pointer types¶

With pointers, several concepts can be connected with them to offer new functionalities.

NULL Pointers¶

The Null Pointers are those pointers that do not point to any memory location. They can be created by assigning a NULL value to the pointer. A pointer of any type can be assigned the NULL value.

int *myIntPtr = NULL;
void *myVoidPtr = NULL;

It is recommended to initialize all pointers to NULL rather than leaving them uninitialized. A good practice is also to assign NULL to unused pointers to be sure the referenced memory segment is still active.

Structure Pointers¶

Pointers to Structs are helpful to handle in functions or to save memory. Read more about this type of pointer in References to Structures.

Function pointers¶

Functions is the basic building block of a C program. Instead of pointing to data with a basic pointer, a function pointer points to functions which results to reference implemented code. Read more about this type of pointer in the subsection References to Functions.

Double Pointers¶

A pointer can reference another pointer, which is called double pointer or pointer-to-pointer.

int myVar = 10;
int *ptr = &myVar;
int **doublePtr = &ptr;

This concept is used for Multidimensional Arrays, data structures, string arrays or function arguments. The double pointer can be extended to int ***triplePtr, int ****quadruplePtr and so on. This is not recommend because it will be very complex to understand and is error-prone.

Void Pointers¶

A void * is a pointer that has no associated data type. It can not be directly dereferenced. It must be casted to the corresponding data type to be dereferenced.

int val = 10;
void *ref = (void*) &val;
printf("Value: %d", *ref/*(1)!*/);
printf("Value: %d", *(int*)ref/*(2)!*/);

A void pointer is mostly used as a reference to not specify a data type, e.g.:

• Data structures to handle any data

• Return value of dynamic allocated memory

• Function arguments of standard functions to handle any data type like memcpy(), memset(), qsort() and many others

Const Pointers¶

A pointer can be used as a read only variable, as a read-only location reference or both together:

• Const pointer

In a constant pointer, the memory address cannot be modified once is defined. This can be used to point always to the same variable like a user data reference.

int valA = 10;
int valB = 5;
int * const constPtr = &valA;

(*constPtr)++; /*(1)!*/
constPtr = &valB; /*(2)!*/

• Pointer to const

The pointer to a constant allows to change the referenced address of the pointer, but not to change the value of the referenced variable. This can be used to reference constant values like default values or get the values from a const array.

int valA = 10;
int valB = 5;
const int *ptrToConst = &valA;

(*ptrToConst)++; /*(1)!*/
ptrToConst = &valB; /*(2)!*/

• Both together

A mix of both systems is also allowed. This can be used to pass to a function a constant variable per reference.

int valA = 10;
int valB = 5;
const int* const constPtrToConst = &valA;

/*(1)! */
(*constPtrToConst)++;
constPtrToConst = &valB;

Pointer Arithmetics¶

A small set of valid operations are allowed for modifying pointers.

• Increment (++) and decrement (--) of a Pointer

  If you increment or decrement a pointer, the address will be changed with the memory size of the defined pointer data type. For Void Pointers, the size will be 1 byte.

• Addition (+) and subtraction (-) of integers to a Pointer

  For the basic addition and subtraction, the same principle is applied as for the incrementation. The integer number of the addition or subtraction gets multiplied with the data type size.

• Difference (aPtr - bPtr) of two Pointers

  The subtraction between two pointer is allowed and will return the number of elements between them. The elements have the size of the used datatype of the pointer.

• Comparison (<>!=) of two Pointers

  All Relational operators can be used with pointers. The data type of the pointer does not matter. Compared is the referenced address.

uint32_t myVar[] = {1, 2};
uint32_t *myPtr = myVar;
myPtr++;
printf("Address before: %p, after increment: %p\n", (void*)myVar, (void*) myPtr);
printf("Difference in increments: %ld\n", myPtr - myVar);
printf("Difference in bytes: %ld\n", (uint8_t*)myPtr - (uint8_t*) myVar);
printf("Stored same address? %s\n", ((double *)myPtr == (void *)myVar) ? "true" : "false");

Pointers Quiz¶

Global vs. local vs. static variables¶

The location of the declaration of a variable in C is important. It defines from where to this variable can be accessed and where it will be stored. In C programming, the variables are only accessible inside the region where they are created. This is called scope. A distinction is made between the following scopes.

Global¶

Variables created outside of a function are called global variable. Global variables are accessible from any scope.

#include <stdio.h>

int x = 17;

void printIncrementedX(void){
    x++;
    printf("X in function is %2d\n", x);
}

int main(void) {
    printIncrementedX();
    x++;
    printf("X in     main is %2d\n", x);
    return 0;
}

Static¶

Static variables have the property of preserving their value even after they are out of their scope. This results their current value being saved and they will not be reinitialized in the new scope.

#include <stdio.h>

void printIncrementedX(void) {
   static int x = 0;
   x++;
   printf("X in function is %2d\n", x);
}

int main() {
   int x = 10;
   for (; x > 0; x--) {
      printIncrementedX();
      printf("X in     main is %2d\n", x);
   }
   return 0;
}

Local¶

Local variables are only accessible in their scope and will be deleted with the corresponding scope.

#include <stdio.h>

void printIncrementedX(void) {
   int x = 0;
   x++;
   printf("X in function is %2d\n", x);
}

int main() {
   int x = 10;
   for (; x > 0; x--) {
      printIncrementedX();
      printf("X in     main is %2d\n", x);
   }
   return 0;
}

Scope Quiz¶

Operators¶

Operators are mathematical and logical operands to modify or compare a variable. C knows three groups of operators, which can be divided into different types.

Unary Operators¶

Unary operators relate their calculation on a single operand. Part of this type are the increment (++) and decrement (–) operators. The position of the operators plays a decisive role in determining when the incrementation takes place.

• Prefix operation When the operant is used in prefix mode (i.e. ++x), the operation is performed before the value is read.

  Example

  uint8_t a = 1;    // => a = 1
  uint8_t b = --a;  // => a = 0, b = 0
  

• Postfix operation When the operant is used in postfix mode (i.e. x--), the operation is performed after the value is read.

  Example

  uint8_t a = 1;    // => a = 1
  uint8_t b = a--;  // => b = 1, a = 0
  

Arithmetic Operators¶

Arithmetical operators includes the elementary arithmetic math operations and the modulo operator.

Relational Operators¶

Relational operators are used to compare two variables and produce a single boolean output.

Logical Operators¶

These operators are used to combine two or more boolean expressions to perform a logical operations and produce a single boolean output.

Bitwise Operators¶

These operators are used to perform bit-level operations on data.

• Bitwise AND &

Bitwise AND operation on every bit of the variables.

uint8_t a = 0x14;  // = 0b00010100 = 20
uint8_t b = 0x0F;  // = 0b00001111 = 15
uint8_t c = a & b; // = 0b00000100 =  4

• Bitwise OR |

Bitwise OR operation on every bit of the variables.

uint8_t a = 0x14;  // = 0b00010100 = 20
uint8_t b = 0x0F;  // = 0b00001111 = 15
uint8_t c = a | b; // = 0b00011111 = 37

• Bitwise XOR ^

Bitwise eXclusive OR operation on every bit of the variable.

uint8_t a = 0x14;  // = 0b00010100 = 20
uint8_t b = 0x0F;  // = 0b00001111 = 15
uint8_t c = a ^ b; // = 0b00011011 = 33

• Bitwise NOT ~

Toggles every bit in the variable.

uint8_t a = 0x14; // = 0b00010100 =  20
uint8_t b = ~a;   // = 0b11101011 = 235

• Bitwise Left Shift <<

Shifts the value to the left and fills up with 0. The surplus bits on the left side are cut off.

uint8_t a = 0x14;   // = 0b00010100 =  20
uint8_t b = a << 3; // = 0b10100000 = 160

• Bitwise Right Shift >>

Shifts the value to the right and fills up with 0. The surplus bits on the right side are cut off.

uint8_t a = 0x14;   // = 0b00010100 = 20
uint8_t b = a >> 3; // = 0b00000010 =  2

Assignment Operators¶

All Arithmetic operators and Bitwise operators can directly be used with the assign operator =. The system to write is always to write the right value to left target.

<target> = <value>;
a = 10;

This shortcut reduce the programming effort and is more efficient. It is mostly used with literal constants.

uint8_t a = 10; // a = 10
a += 10;        // a = 20
a |= 0x01;      // a = 0x14 | 0x01 = 0x15

Ternary Operator¶

THe ternary or conditional operator is a special operator which takes three operands. It is a short-hand if-else condition to reduce multiple coding lines in one for simple conditions. For complex or longer conditions, it is recommend to use the basic if-else condition.

variable = (condition) ? expressionTrue :  expressionFalse;

uint8_t a = 10;
uint8_t b = 15;
uint8_t max = (a > b) ? a : b;

Operators Quiz¶

Functions¶

A function in C is a set of statements that, when called, perform some certain tasks. It is the basic building block of a C program that provides modularity and code reusability. The programming statements of a function are enclosed within braces { }, having certain meanings and performing certain operations. They are also called subroutines or procedures in other languages.

Declaration (prototype) and definition (implementation)¶

Function prototypes defines the return type, the name and the arguments of a function. In the C language, each basic function requires a unique name and cannot be overloaded as in C++.

returnType functionName(type argument1, type argument2, ...);

int diff(int minuend, int subtrahend);

The location of the prototype is important that the function is recognised by other functions. The prototype must be defined before using it in other functions. Generally they are defined at the beginning of the source file for private functions or in the header file for public functions.

#include <stdio.h>

int diff(int minuend, int subtrahend);
//(1)! int sum(int a, int b);

int main(void) {
  int a = 10;
  int b = 6;
  int diffRes = diff(a, b);
  printf("%d - %d = %d\n", a, b, diffRes);
  int sumRes = sum(a, b); //(2)!
  printf("%d + %d = %d\n", a, b, sumRes);
}

int sum(int a, int b); //(3)!

int diff(int minuend, int subtrahend) { return minuend - subtrahend; }

int sum(int a, int b) { return a + b; }

Passing arguments¶

Information can be passed to functions as a parameter. Parameters act as variables inside the function. Parameters are specified after the function name, inside the parentheses. You can add as many parameters as you want, just separate them with a comma.

In C, all arguments are copied to the function. By using pointers, only the address of the argument is copied. This results in two basic methods to pass a variable into the function:

• Call by value:

Call by value in C is the argument is set with a value and this value can be used in function for performing the operation. Values passed in the function are stored in the function memory so the changes performed in the function do not affect the actual value of the variable passed.

#include <stdio.h>

// Call by value example
int sum(int x, int y) {
  return x + y;
}

int main() {
  int a = 3, b = 2;
  // Function Called
  int r = sum(a, b);
  printf("Sum of %d and %d = %d\n", a, b, r);

  return 0;
}

• Call by reference:

Call by reference is the method in C where the function is called with passing a memory address as an argument. The address is passed as a pointer. A change performed in the value inside the function is also performed to the value of the variable outside the function. With this method, not only one value can be returned to the user. Another advantage is the effort of the CPU to only copy the address instead of copy the hole object. For this reason, this method is generally used for Structs. For more safety to not modify anything of the reference, remember on the section Const Pointers.

#include <stdio.h>

// Call by reference
void swap(int *x, int *y) {
  int temp = *x;
  *x = *y;
  *y = temp;
}

int main() {
  // Declaring Integer
  int x = 1, y = 5;
  printf("Before swap: x:%d, y:%d\n", x, y);
  // Calling the function
  swap(&x, &y);
  printf("After swap:  x:%d, y:%d\n", x, y);
  return 0;
}

Return types¶

The return value can be used as the result of the function, as a function state or without any return value, represented with void. A good practice is when returning the result of the function, a calculated impossible value is used as a failure value. Using an enumeration with a Typedef to make the states more readable is a good practice.

References to Functions¶

Any function in a program also has a memory address. Instead of pointing to data, references to functions point to implemented code. This results in storing the starting address of executable code. The user-friendliness of a function pointer consists of offering a high level of abstraction with a high degree of flexibility for the user.

• Declaration

To reference to a function, the function pointer must be created. The pointer needs the return type, a name and the arguments types:

returnType (*functionPointerName)(argumentType, argumentType...);

int (*myFunction_ptr)(int, double, char);

• Initialisation

The function pointer is initialised with a function of the same format (same return type and arguments).

returnType myFunctionName(type1 argName1, type2 argName2)
returnType (*functionPointerName)(type1, type2);
functionPointerName = myFunctionName;

int myFunction(int number, double real, char character);
int (*myFunction_ptr)(int, double, char);
myFunction_ptr = myFunction;

• Calling a function pointer

A function pointer is called like a normal function.

myFunctionPtrName(argumentType1, argumentType2);

myFunction_ptr(a,b,c);

#include <stdio.h>

int operate(int a, int b, char *operationName, int (*operation)(int, int) /*(1)!*/);

int sum(int a, int b); //(2)!
int diff(int minuend, int subtrahend);

int main(void) {
  int a = 10;
  int b = 6;
  operate(a, b, "sum", sum /*(3)!*/);
  operate(a, b, "difference", diff);
  return 0;
}

int operate(int a, int b, char *operationName, int (*operation)(int, int)) {
  int res = operation(a, b);/*(4)!*/
  printf("Operation %s with numbers: %d and %d = %d\n", operationName, a, b, res);
  return res;
}

int sum(int a, int b) {
  return a + b;
}

int diff(int minuend, int subtrahend) {
  return minuend - subtrahend;
}

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

// Comparison function
int compare(const void *a, const void *b) {
  return (*(int *)a - *(int *)b);
}

void printArray(int theArray[], size_t n) {
  for (size_t i = 0; i < n; ++i) {
    printf("%2d ", theArray[i]);
  }
}

#define NEW_LINE (puts(""))

int main() {
  int arr[] = {10, 5, 4, 6, 9};
  int n = sizeof(arr) / sizeof(arr[0]);
  printf("Following the input array:  ");
  printArray(arr, n);
  NEW_LINE;

  qsort(arr, n, sizeof(arr[0]), compare);

  printf("Following the sorted array: ");
  printArray(arr, n);
  NEW_LINE;

  return 0;
}

Functions Quiz¶

Arrays¶

An array in C is one of the most used data structures. It is a simple and fast way of storing multiple values under a single name.

Array definition¶

An array in C is a fixed-size collection of similar data items stored in contiguous memory locations. It can be used to store the collection of primitive data types such as int, char, float, etc. and also derived or user-defined data types such as pointers, structures, etc.

To create an array, square brackets [ ] are used after the name and the braces { } are used to initialise the array. There are different possibilities to create an array:

type arrayName[<sizeDeclaration>] = {<initValue>};

int arrayName[3];

int arrayName[3] = {0};     // Initialise ALL elements with 0
int arrayName[3] = {1};     // Initialise the FIRST element with 1
int arrayName[3] = {1,2,3}; // Initialise the array with 1, 2 and 3

int arrayName[] = {1,2,3}; // Creates an array with a size of 3 with values 1,2,3

Array access¶

Accessing the array by the name results in receiving the address of the first element of the array. To get access to an element, the array subscript operator [ ] is needed with the desired index. The first element has the index 0.

int myArray[3] = {1,2,3};//(1)!
int * arrayRef = myArray;//(2)!
int value1 = myArray[0];//(3)!
int value2 = myArray[1];
int value2 = myArray[2];
int value3 = myArray[3];//(4)!

Multidimensional Arrays¶

Arrays are not limited as a line, they can be used as two dimensional areas, three dimensional rectangular cuboids and so on. The initialisation and access use the same principle as for one dimensional arrays.

int my2dArray[2][3] = {{1,2,3},{11,12,13}};
int firstElement = my2dArray[0][0];

Array Quiz¶

Enumerations¶

Enumerations are used for naming signed int values, similar to constants. The keyword enum results in followed syntax:

enum [name]{ENUMERATOR_1, ENUMERATOR_2, ... , ENUMERATOR_n};

An enumerator is either only a name or a name with a given value. If no value is given, the value of the previous enumerator + 1 is taken (starting at 0):

enum colors{RED, GREEN, BLUE, YELLOW};
// RED=>0(1), GREEN=>1, BLUE=>2 , YELLOW=>3
enum power{OFF, ON, CLOSED = 0/*(2)!*/, OPENED};
// OFF=>0, ON=>1, CLOSED=>0, OPENED=1

Enumeration Quiz¶

Structs¶

Structures or short called structs are a way to group several variables into one object. Each variable in the structure is called a member of the structure. Unlike an array, a structure can contain many different data types (int, float, char, etc.).

Structure declaration¶

You can create a structure by using the struct keyword and declare each of its members inside braces {}. A structure can be defined with a name or anonymously, but the anonymous structure requires an instance.

struct [name] {
   type_x member_1;
   type_y member_2;
   // ...
   type_z member_N;
} [instances];

Structure access¶

An object of the structure is called instance. The instance can be created like an normal variable or directly in the structure definition. To get access of the member, the structure member operator dot . is used. The initialisation can be summarised in braces {} accessed with the structure member operator or member by member with the same operator.

struct coordinates{
      int x;
      int y;
};

struct coordinates startPoint = {
   .x = 1,
   .y = 2
};

struct coordinates endPoint;
endPoint.x = 1;
endPoint.y = 2;

References to Structures¶

A pointer can reference a structure. This is mostly used for function arguments which use a structure, because it is in the most cases faster to copy the address instead the entire structure. To access to an element, the basic pointer method can be used by using the base principles of both types with the indirection operator (*) and the dot operator (.), but it gives a much better method with the membership operator (->).

#include <stdio.h>
#include <math.h>

struct coordinates {
  double x;
  double y;
};

double distance(const struct coordinates *const start,const struct coordinates *const end) {
    double diffX = end->x - (*start).x;
    double diffY = (*end).y - start->y;
    return sqrt(pow(diffX, 2) + pow(diffY, 2));
}

int main(void) {

  struct coordinates startPoint = {.x = 0.0f, .y = 1.5f};

  struct coordinates endPoint;
  endPoint.x = 3.0f;
  endPoint.y = 5.5f;

  printf("Distance is %.3f\n", distance(&startPoint, &endPoint));

  return 0;
}

Structures Quiz¶

Typedef¶

To set an alternate name to an existing datatype, the keyword typedef is used with followed syntax:

typedef TYPE ALIAS_NAME;

This feature can be used to define own structure or enumeration types. By using the new type, there is no need to repeatedly write struct or enum.

typedef struct{
   int a;
}MyStruct;

typedef enum {STATE_OK, STATE_WAITING, STATE_ERROR}myState;

myState example(MyStruct *data);

Typedef Quiz¶

Characters and C-Strings¶

The C String is stored as an array of characters terminated with the null character '\0'. The Null Character in C is a special character with an ASCII value of 0 (zero). It is not the same as the character '0' which has an ASCII value of 48. The null character in C at the end of the string ensures that functions and libraries designed to work with C strings can correctly identify the string’s length and avoid buffer overflows. This concept must always be applied, otherwise unpredictable behavior may occur.

String Initialisation¶

A string can be initialised in different ways, but not all methods need the null terminator implemented by the user.

char str[] = "C is fun!";//(1)!

char str[20] = "C is fun!";//(1)!

char str[20] = {'C',' ','i','s',' ','f','u','n','!','\0'};//(1)!

char str[] = {'C',' ','i','s',' ','f','u','n','!','\0'};//(1)!

char *str = "C is fun!";//(1)!

C String Handling¶

Because a C string is fundamentally an array, copying, extending, or modifying it requires more effort than just applying the basic arithmetics as in other programming languages. A C standard library included with #include <string.h> offers many helpful functions to handle this functionality for C strings. A list of all functions including a description and an example can be found at cplusplus.com/reference/cstring/.

#define destSize (40)
char src[]="Sample string";
char dest[destSize];
strcpy(dest, src);//(1)!

#define destSize (40)
char src[]="Sample string";
char dest[destSize];
strncpy(dest, src, destSize-1/*(1)!*/);//(2)!

Strings Quiz¶