Data commit

Task/Array-length/C/array-length-1.c

@@ -0,0 +1,21 @@
+#include <stdio.h>
+
+int main()
+{
+    const char *fruit[2] = { "apples", "oranges" };
+
+    // Acquire the length of the array by dividing the size of all elements (found
+    // with sizeof(fruit)) by the size of the first element.
+
+    // Note that since the array elements are pointers to null-terminated character
+    // arrays, the size of the first element is actually the size of the pointer
+    // type - not the length of the string.
+
+    // This size, regardless of the type being pointed to, is 8 bytes, 4 bytes, or
+    // 2 bytes on 64-bit, 32-bit, or 16-bit platforms respectively.
+    int length = sizeof(fruit) / sizeof(fruit[0]);
+
+    printf("%d\n", length);
+
+    return 0;
+}

Task/Array-length/C/array-length-2.c

@@ -0,0 +1 @@
+#define ARRAY_LENGTH(A) (sizeof(A) / sizeof(A[0]))

Task/Array-length/C/array-length-3.c

@@ -0,0 +1,76 @@
+#define _CRT_SECURE_NO_WARNINGS    // turn off panic warnings
+#define _CRT_NONSTDC_NO_WARNINGS   // enable old-gold POSIX names in MSVS
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+
+struct StringArray
+{
+    size_t sizeOfArray;
+    size_t numberOfElements;
+    char** elements;
+};
+typedef struct StringArray* StringArray;
+
+StringArray StringArray_new(size_t size)
+{
+    StringArray this = calloc(1, sizeof(struct StringArray));
+    if (this)
+    {
+        this->elements = calloc(size, sizeof(int));
+        if (this->elements)
+            this->sizeOfArray = size;
+        else
+        {
+            free(this);
+            this = NULL;
+        }
+    }
+    return this;
+}
+
+void StringArray_delete(StringArray* ptr_to_this)
+{
+    assert(ptr_to_this != NULL);
+    StringArray this = (*ptr_to_this);
+    if (this)
+    {
+        for (size_t i = 0; i < this->sizeOfArray; i++)
+            free(this->elements[i]);
+        free(this->elements);
+        free(this);
+        this = NULL;
+    }
+}
+
+void StringArray_add(StringArray this, ...)
+{
+    char* s;
+    va_list args;
+    va_start(args, this);
+    while (this->numberOfElements < this->sizeOfArray && (s = va_arg(args, char*)))
+        this->elements[this->numberOfElements++] = strdup(s);
+    va_end(args);
+}
+
+
+int main(int argc, char* argv[])
+{
+    StringArray a = StringArray_new(10);
+    StringArray_add(a, "apple", "orange", NULL);
+
+    printf(
+        "There are %d elements in an array with a capacity of %d elements:\n\n",
+        a->numberOfElements, a->sizeOfArray);
+
+    for (size_t i = 0; i < a->numberOfElements; i++)
+        printf("    the element %d is the string \"%s\"\n", i, a->elements[i]);
+
+    StringArray_delete(&a);
+
+    return EXIT_SUCCESS;
+}

Task/Array-length/C/array-length-4.c

@@ -0,0 +1,112 @@
+#define _CRT_SECURE_NO_WARNINGS    // turn off panic warnings
+#define _CRT_NONSTDC_NO_WARNINGS   // enable old-gold POSIX names in MSVS
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define N 10
+
+// Fixed size global arrays
+
+static const int scGlobal[N];
+const int cGlobal[N];
+static int sGlobal[N];
+int Global[N];
+
+#define TEST(A, N)                                                             \
+ do {                                                                          \
+    puts("");                                                                  \
+    printf("directly called:          sizeof(%8s) = %2d,  length = %2d,  %s\n",\
+        #A,                                                                    \
+        sizeof(A),                                                             \
+        sizeof(A) / sizeof(int),                                               \
+        sizeof(A) / sizeof(int) == N ? "pass" : "fail");                       \
+                                                                               \
+    test1(#A, A, N);                                                           \
+    test2(#A, A, N);                                                           \
+    test3(#A, A, N);                                                           \
+} while (0);
+
+void test1(char* name, int* A, int n)
+{
+    printf("as parameter int* A:      sizeof(%8s) = %2d,  length = %2d,  %s\n",
+        name,
+        sizeof(A),
+        sizeof(A) / sizeof(int),
+        sizeof(A) / sizeof(int) == n ? "pass" : "fail");
+}
+
+void test2(char* name, int A[], int n)
+{
+    printf("as parameter int A[]:     sizeof(%8s) = %2d,  length = %2d,  %s\n",
+        name,
+        sizeof(A),
+        sizeof(A) / sizeof(int),
+        sizeof(A) / sizeof(int) == n ? "pass" : "fail");
+}
+
+void test3(char* name, int A[10], int n)
+{
+    printf("as parameter int A[10]:   sizeof(%8s) = %2d,  length = %2d,  %s\n",
+        name,
+        sizeof(A),
+        sizeof(A) / sizeof(int),
+        sizeof(A) / sizeof(int) == n ? "pass" : "fail");
+}
+
+
+int main(int argc, char argv[])
+{
+    // Fixed size local arrays (defined inside curly braces block)
+
+    static const int scLocal[N];
+    const int cLocal[N];
+    static int sLocal[N];
+    auto int aLocal[N];
+    int Local[N];
+
+    // Fixed size VLA arrays can/should be used instead dynamically alocated
+    // blocks. VLA has not implemented in Microsoft Visual Studio C.
+
+    srand(time(NULL));
+    int n = N + rand() % 2; // the value of n is unknow in the compile time?
+
+#ifndef _MSC_VER
+    int vlaLocal[n];
+#endif
+
+    // Memory blocks as ersatz arrays. This is not all possible ways to allocate
+    // memory. There are other functions, like LocalAlloc, HeapAlloc, sbreak...
+    // Don't use alloca in any serious program - this function is really bad
+    // choice - it can corrupt the program stack and generate a stack overflow.
+
+    int* mBlock = (int*)malloc(n * sizeof(int));
+    int* cBlock = (int*)calloc(n, sizeof(int));
+    int* aBlock = (int*)_alloca(n * sizeof(int)); // don't use in your programs!
+
+    TEST(scGlobal, N);
+    TEST(cGlobal, N);
+    TEST(sGlobal, N);
+    TEST(Global, N);
+
+    TEST(scLocal, N);
+    TEST(cLocal, N);
+    TEST(sLocal, N);
+    TEST(aLocal, N);
+    TEST(Local, N);
+
+#ifndef _MSC_VER
+    TEST(vlaLocal, n);
+#endif
+
+    TEST(mBlock, N);
+    TEST(cBlock, N);
+    TEST(aBlock, N);
+
+    free(mBlock, N);
+    free(cBlock, N);
+    // free must not be called on aBlock
+
+    return 0;
+}