A function type describes a function that returns a value of a specified type. If the function returns no value, it should be declared as "function returning void " as follows:

void function1();

int uppercase(int lc){
  int uc = lc + 0X20;
  return uc;
}

- A pointer type describes a value that represents the **address** of an object of a stated type. - A pointer is stored as an integral value that references the address of the target object. - Pointer types are derived from other types, called the referenced type of the pointer. Example:

int *p;          /*  p is a pointer to an int type */
double *q();     /*  q is a function returning a pointer to an object of type double */
int (*r)[5];     /*  r is a pointer to an array of five elements */
                 /*  (r holds the address to the first element of the array) */
const char s[6]; /*  s is a const-qualified array of 6 elements */

int *prt = (int *) malloc(10*sizeof(int));

int MPI_Send(const void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm);

An array is a data structure that can store a fixed-size sequential collection of elements of the same type. Arrays cannot be of void or function type, since the void type cannot be completed and function types are not object types requiring storage.

int nvec = 107;

/* allocate memory */
double *vec = (double *) malloc(nvec*sizeof(double));

vec[0] = 1.1234534631246;
for (int i = 1 ; i < nvec; ++i) {
  vec[i] = 2.0*vec[i-1];
}

/* deallocate memory */
free(vec); vec = NULL;

/* allocate first dimension */
int **two_dim = (int **) malloc(10 * sizeof(int *));

/* allocate second dimension */
for (int j = 0; j < 10; ++j) {
  two_dim[j] = (int *) malloc(25*sizeof(int));
}

/* fill array of arrays: i-index is contiguous in memory */
for (int j = 0; j < 10; ++j) {
  for (int i = 0; i < 25; ++i) {
    two_dim[j][i] = 2*j + i;
  }
}

/* deallocate memory */
for (int j = 0; j < 10; ++j) {
  free(two_dim[j]); two_dim[j] = NULL;
}
free(two_dim); two_dim = NULL;

A structure type is a sequentially allocated nonempty set of objects, called members, allowing grouping of heterogeneous data. Unlike arrays, the elements of a structure need not be of the same data type. Also, elements of a structure are accessed by name, not by subscript.

struct [structure tag] {
  member definition;
  member definition;
  ...
  member definition;
} [one or more structure variables];  

struct student {
  char name[30];
  int age;
};

struct student andrew, ed, mary;

// access member
andrew.age = 21;

A **union** is a special data type available in C that allows to store different data types in the same memory location. You can define a union with many members, but only one member can contain a value at any given time. Unions provide an efficient way of using the same memory location for multiple-purpose.

union [union tag] {
   member definition;
   member definition;
   ...
   member definition;
} [one or more union variables];  

union Data {
   int i[6];
   double f[2];
   char str[20];
} data;

  int i[6]: (4 bytes per int) * (6 ints) = 24 bytes  
  double f[2]: (8 bytes per double) * (2 doubles) = 16 bytes  
  char str[20]: (1 byte per char) * (20 chars) = 20 bytes

- The qualifier `const` can be applied to the declaration of any variable to **specify that its value will not be changed.**

const int a = 7;
int const b = 8;

int const *ptr; 
const int *ptr;

#include <stdio.h>

int main(void){
  int i = 10;
  int j = 20;

  const int *ptr = &i; // ptr is pointer to constant 

  printf("ptr: %d\n", *ptr);
  *ptr = 100; // error: object pointed cannot be modified using the pointer ptr

  ptr = &j;  // valid 
  printf("ptr: %d\n", *ptr);

  return 0;
}

 error: assignment of read-only location ‘*ptr’

#include <stdio.h> 

int main(void){
  int const i = 10; // i is stored in read only area
  int j = 20;

  /* Pointer to integer constant:
   *  i is of type "const int"
   * &i is of type "const int *"
   *  p is of type "const int" 
   */
  int const *ptr = &i;
  printf("ptr: %d\n", *ptr);

  *ptr = 100; // error

  /* valid. We call it up qualification.
   * In C/C++, the type of "int *" is allowed to up qualify to the type "const int *".
   * The type of &j is "int *" and is implicitly up qualified by the compiler to "const int *".
   */
  ptr = &j;
  printf("ptr: %d\n", *ptr);

  return 0;
}

error: assignment of read-only location ‘*ptr’

int *const ptr; 

#include <stdio.h> 

int main(void){
  int i = 10;
  int j = 20;

  /* constant pointer to integer */
  int *const ptr = &i;

  printf("ptr: %d\n", *ptr);

  *ptr = 100; /* valid */
  printf("ptr: %d\n", *ptr); 

  ptr = &j; /* error */
  return 0;
}

error: assignment of read-only variable ‘ptr’

const int *const ptr; 

#include <stdio.h>

int main(void){ 
  int i = 10;
  int j = 20;

  /* constant pointer to constant integer */
  const int *const ptr = &i;
  printf("ptr: %d\n", *ptr);

   ptr = &j;  /* error */
  *ptr = 100; /* error */

  return 0;
}

error: assignment of read-only variable ‘ptr’
error: assignment of read-only location ‘*ptr’

- The `volatile` qualifier tells the compiler that the **value of the variable may change at any time, without any action being taken by the code** the compiler finds nearby. - Volatile accesses cannot be optimized out or reordered with another visible side effect that is sequenced-before or sequenced-after the volatile access. - This qualifier is used primarily in embedded programming of devices, e.g. mobile phones, washing machines, and digital cameras.

- `restrict` is a keyword used in pointer declarations: hints to the compiler that for the lifetime of the pointer, only the pointer itself or a value directly derived from it (such as pointer + 1) will be used to access the object to which it points. - `restrict` limits the effects of pointer aliasing, aiding optimizations. If the declaration of intent is not followed and the object is accessed by an independent pointer, this will result in undefined behavior. If the compiler knows that there is only one pointer to a memory block, it can produce better optimized code. For instance:

void updatePtrs(size_t *restrict ptrA, size_t *restrict ptrB, size_t *restrict val){
  *ptrA += *val;
  *ptrB += *val;
}

- Static variables have a property of preserving their value even after they are out of their scope! - Static variables preserve their previous value in their previous scope and are not initialized again in the new scope.

#include<stdio.h>
int fun(){
  static int count = 0;
  count++;

  return count;
}

int main(void){
  printf("Count = %d", fun());
  printf("Count = %d", fun());
  return 0;
}

Count = 1
Count = 2

- An object declaration outside of a function is called an **external declaration**. - If the file does not include the file provides the compiler with sufficient information to access a variable declared in another file. Later in the semester when we build libraries, we will see be utilized to prevent *name mangling* with `extern "C"{...}`. :large_orange_diamond: [Deepnote: Name Mangling](https://deepnote.com/project/fdeed75f-9b4a-428c-8bb7-3766103008ee#%2FC-Basics%2FHelloWorldNameMangle%2Fhello_1.c)