clang.md

#include < limits .h >

int foo(int a)
{
    int b = INT_MAX + a; // UB, b can be anything
    return b;
}
#include <stdio.h>

int func() {
    int gv;
    printf("Enter a integer number: ");
    scanf("%d", &gv);
    return (23 / func()); // UB
}
int foo(int* p)
{
    int x = *p;
    if (!p)
        return x; // Either UB above or this branch is never taken
    else
        return 0;
}

int bar()
{
    int* p = NULL;
    return *p;    // Unconditional UB
}
int* fun(int x) {
    int y = 2;
    y = x + y;
    return *y; // UB
}
#include <stdio.h>

int main() {
    int a;
    int b = a; // UB
    printf("a = %d\n", a);
    printf("b = %d\n", b);
    return 0;
}
#include <stdio.h>

int main() {
    char *p = "some text here";
    p[2] = 'O'; // UB
}
#include <stdio.h>

int main() {
    int arr[5] = { 1, 2, 3, 4, 5 };
    int b = arr[7]; // UB
    printf("b = %d\n", b);
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
  char str[9] = "tutorial";
  char ftr[9] = "aftertut";
  int bufsize = strlen(str) + 1;
  char *buf = (char *)malloc(bufsize);
  if (!buf) {
    return EXIT_FAILURE;
  }
  free(buf);
  strcpy(buf, ftr); // UB
  printf("buf = %s\n", buf);

  return EXIT_SUCCESS;
}
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int main(void) {
    bool keep_going = true;  // Could also be `bool keep_going = 1;`
    while(keep_going) {
        printf("This will run as long as keep_going is true.\n");
        keep_going = false;    // Could also be `keep_going = 0;`
    }
    printf("Stopping!\n");
    return EXIT_SUCCESS;
}
int x;
float y;
y = (float) x;
typedef struct {
    int x;
    int y;
} Pointer;

void foo(void *v) {
    ((Pointer *) v)->x = 24;
}
#include <stdio.h>
#include <stdlib.h>

int main() {
  int num = 9;
  int *ptr= (int *)malloc(sizeof(int));
  ptr = &num;
  printf("ptr: %d", *ptr);
  return 0;
}
char c[] = "abcd";

char c[50] = "abcd";

char c[] = {'a', 'b', 'c', 'd', '\0'};

char c[5] = {'a', 'b', 'c', 'd', '\0'};

char str* = "string literal"; // can not be modified via array subscript
#include <stdio.h>
#include <stdlib.h>

/* static storage duration */
int A;

int main(void)
{
    printf("&A = %p\n", (void*)&A);

    /* automatic storage duration */
    int A = 1;   // hides global A
    printf("&A = %p\n", (void*)&A);

    /* allocated storage duration */
    int *ptr_1 = malloc(sizeof(int));   /* start allocated storage duration */
    printf("address of int in allocated memory = %p\n", (void*)ptr_1);
    free(ptr_1);                        /* stop allocated storage duration  */
}
#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
  int val;
  struct TreeNode* left;
  struct TreeNode* right;
};

struct TreeNode* create_node(int val) {
  struct TreeNode* node = (struct TreeNode*) malloc(sizeof(struct TreeNode));
  node->val = val;
  node->left = NULL;
  node->right = NULL;
  return node;
}

// Traverse the tree in-order and print the values
void traverse(struct TreeNode* node) {
  if (node == NULL) {
    return;
  }
  traverse(node->left);
  printf("%d ", node->val);
  traverse(node->right);
}


struct TreeNode* insert(struct TreeNode* root, int val) {
  if (root == NULL) {
    return create_node(val);
  }
  if (val < root->val) {
    root->left = insert(root->left, val);
  } else {
    root->right = insert(root->right, val);
  }
  return root;
}

int main() {
  struct TreeNode* root = NULL;
  root = insert(root, 5);
  root = insert(root, 3);
  root = insert(root, 7);
  root = insert(root, 2);
  root = insert(root, 4);
  root = insert(root, 6);
  root = insert(root, 8);
  traverse(root);
  return 0;
}
#define twox(x) (x + x)

// twox(3); => (3 + 3);

// this could lead to unexpected behaviours
// int y = 2;
// int z = twox(y++); => z = (y++ + y++);  the value of z actaully depends on the order of evaluation
#define ARR_SIZE 100
#include <stdio.h>

int main() {
#ifdef __linux__
    printf("I am the Happy Penguin!\n");
#elif _WIN32
    printf("Welcome to MS Windows ( I rule!).\n");
#elif __APPLE__&&__MACH__
    printf("Welcome to I am cool!\n");
#else
    printf("Uh! who am i?\n");
#endif
}
#ifndef BAR_H
#define BAR_H

int func(void) { return 1; }

#endif /* BAR_H */
#include "bar.h"
#include "bar.h" // Repeated inclusion is // usually not this obvious.

int main(void) {
    return func();
}
// flib.h
#ifndef FLIB_H
#define FLIB_H
    void f(void);              // function declaration with external linkage
    extern int state;          // variable declaration with external linkage
    static const int size = 5; // definition of a read-only variable with internal linkage
    enum { MAX = 10 };         // constant definition
#endif // FLIB_H
// flib.c
#include "flib.h"
static void local_f(int s) {}  // definition with internal linkage (only used in this file)
static int local_state;        // definition with internal linkage (only used in this file)

int state;                     // definition with external linkage (used by main.c)
void f(void) { local_f(state); } // definition with external linkage (used by main.c)
// main.c
#include "flib.h"
int main(void)
{
    int x[MAX] = {size}; // uses the constant and the read-only variable
    state = 7;           // modifies state in flib.c
    f();                 // calls f() in flib.c
}
#include <stdio.h>

void foo() {
    static int count = 0; // count has no linkage but has static storage duration
    printf("Function has been called %d times\n", ++count);
}

int main() {
    foo();
    foo();
    foo();
    return 0;
}