Support more languages for review

Author: Awrsha

03 C C++ Python R and Mojo review/03-2 Python Review/01 Pointers/03.py

@@ -0,0 +1,11 @@
+# Python does not have pointers like C, but we can simulate similar behavior using references
+
+num = 10
+fnum = 3.14
+
+# Simulating a void pointer behavior by storing references in a dictionary
+vptr = {"type": "int", "value": num}
+print(f"Integer: {vptr['value']}")  # Output: 10
+
+vptr = {"type": "float", "value": fnum}
+print(f"Float: {vptr['value']:.2f}")  # Output: 3.14

03 C C++ Python R and Mojo review/03-2 Python Review/01 Pointers/04.py

@@ -0,0 +1,24 @@
+# Simulating NULL pointer behavior in Python using None
+
+ptr = None  # Initializing to None (similar to NULL in C)
+print(f"1. Initial ptr value: {ptr}")
+
+# Check for None (NULL) before using
+if ptr is None:
+    print("2. ptr is None, cannot dereference")
+
+# Simulate memory allocation
+ptr = 42  # Allocating a value to ptr
+print(f"4. After allocation, ptr value: {ptr}")
+
+# Safe to use ptr after checking for None
+if ptr is not None:
+    print(f"5. Value at ptr: {ptr}")
+
+# Simulate freeing memory (set to None after use)
+ptr = None
+print(f"6. After free, ptr value: {ptr}")
+
+# Safety check after 'free' (set to None)
+if ptr is None:
+    print("7. ptr is None, safely avoided use after free")

03 C C++ Python R and Mojo review/03-2 Python Review/01 Pointers/05.py

@@ -0,0 +1,11 @@
+# Python equivalent for iterating through an array-like structure
+
+arr = [12, 24, 36, 48, 60]
+
+# Position one (first element)
+print(f"Position one: {arr[0]}")
+
+# Iterate over the array and simulate printing memory address
+for num in arr:
+    print(f"{num}\t{id(num)}")
+    # id() gives a unique identifier for the object, similar to a memory address

03 C C++ Python R and Mojo review/03-2 Python Review/01 Pointers/06.py

@@ -0,0 +1,10 @@
+# Python equivalent for simulating matrix-like behavior using lists
+
+arr1 = [1, 2, 3, 4]
+arr2 = [5, 6, 7, 8]
+matrix = [arr1, arr2]
+
+for row in matrix:
+    for i in range(len(row)):
+        print(row[i], end=" ")
+    print()

03 C C++ Python R and Mojo review/03-3 R Language Review/01 Pointers/03.R

@@ -0,0 +1,9 @@
+num <- 10
+fnum <- 3.14
+
+# Simulating the void pointer with a list containing references
+vptr <- list(type = "int", value = num)
+cat("Integer:", vptr$value, "\n")  # Output: 10
+
+vptr <- list(type = "float", value = fnum)
+cat("Float:", sprintf("%.2f", vptr$value), "\n")  # Output: 3.14

03 C C++ Python R and Mojo review/03-3 R Language Review/01 Pointers/04.R

@@ -0,0 +1,27 @@
+# Simulating NULL pointer behavior in R
+
+ptr <- NULL  # Initialize ptr as NULL
+cat("1. Initial ptr value:", ptr, "\n")
+
+# Check for NULL before using
+if (is.null(ptr)) {
+    cat("2. ptr is NULL, cannot dereference\n")
+}
+
+# Simulate memory allocation
+ptr <- 42  # Assigning a value to ptr (simulating allocation)
+cat("4. After allocation, ptr value:", ptr, "\n")
+
+# Safe to use ptr after NULL check
+if (!is.null(ptr)) {
+    cat("5. Value at ptr:", ptr, "\n")
+}
+
+# Simulate freeing memory (set to NULL after use)
+ptr <- NULL
+cat("6. After free, ptr value:", ptr, "\n")
+
+# Safety check after 'free' (set to NULL)
+if (is.null(ptr)) {
+    cat("7. ptr is NULL, safely avoided use after free\n")
+}

03 C C++ Python R and Mojo review/03-3 R Language Review/01 Pointers/05.R

@@ -0,0 +1,12 @@
+# R equivalent for iterating through an array-like structure
+
+arr <- c(12, 24, 36, 48, 60)
+
+# Position one (first element)
+cat("Position one:", arr[1], "\n")
+
+# Iterate over the array and simulate printing memory address
+for (num in arr) {
+    cat(num, "\t", pryr::address(num), "\n")
+    # pryr::address() returns a simulated memory address in R
+}

03 C C++ Python R and Mojo review/03-3 R Language Review/01 Pointers/06.R

@@ -0,0 +1,12 @@
+# R equivalent for simulating matrix-like behavior using lists
+
+arr1 <- c(1, 2, 3, 4)
+arr2 <- c(5, 6, 7, 8)
+matrix <- list(arr1, arr2)
+
+for (row in matrix) {
+  for (value in row) {
+    cat(value, " ")
+  }
+  cat("\n")
+}

03 C C++ Python R and Mojo review/03-4 Mojo Review/01 Pointers/03.mojo

@@ -0,0 +1,9 @@
+num = 10
+fnum = 3.14
+
+# Simulating the void pointer and dereferencing by casting in Mojo
+vptr = &num
+print(f"Integer: {*(int*)vptr}")  # Output: 10
+
+vptr = &fnum
+print(f"Float: {*(float*)vptr:.2f}")  # Output: 3.14

03 C C++ Python R and Mojo review/03-4 Mojo Review/01 Pointers/04.mojo

@@ -0,0 +1,25 @@
+// Simulating NULL pointer behavior in Mojo
+
+var ptr: *int = null  // Initialize pointer to NULL
+print("1. Initial ptr value: ", ptr)
+
+if (ptr == null) {
+    print("2. ptr is NULL, cannot dereference")
+}
+
+// Simulate memory allocation
+ptr = alloc(int)  // Allocating memory for an integer
+ptr! = 42  // Dereferencing and assigning a value
+print("4. After allocation, ptr value: ", ptr)
+
+if (ptr != null) {
+    print("5. Value at ptr: ", ptr!)
+}
+
+// Simulate freeing memory (set to NULL after use)
+ptr = null
+print("6. After free, ptr value: ", ptr)
+
+if (ptr == null) {
+    print("7. ptr is NULL, safely avoided use after free")
+}