+ boost.asio

Author: wyrover

Beginning C, 5th Edition/Chapter 08/program8_01.c

@@ -0,0 +1,17 @@
+// Program 8.1 Scoping out scope
+#include <stdio.h>
+
+int main(void)
+{
+    int count1 = 1;                               // Declared in outer block
+
+    do {
+        int count2 = 0;                             // Declared in inner block
+        ++count2;
+        printf("count1 = %d     count2 = %d\n", count1, count2);
+    } while (++count1 <= 5);
+
+    // count2 no longer exists
+    printf("count1 = %d\n", count1);
+    return 0;
+}

Beginning C, 5th Edition/Chapter 08/program8_02.c

@@ -0,0 +1,16 @@
+// Program 8.2 More scope in this example
+#include <stdio.h>
+
+int main(void)
+{
+    int count = 0;                       // Declared in outer block
+
+    do {
+        int count = 0;                     // This is another variable called count
+        ++count;                           // this applies to inner count
+        printf("count = %d\n", count);
+    } while (++count <= 5);              // This works with outer count
+
+    printf("count = %d\n", count);     // Inner count is dead, this is outer count
+    return 0;
+}

Beginning C, 5th Edition/Chapter 08/program8_03.c

@@ -0,0 +1,50 @@
+// Program 8.3 Calculating an average using functions
+#define __STDC_WANT_LIB_EXT1__ 1
+#include <stdio.h>
+#define MAX_COUNT 50
+
+// Function to calculate the sum of array elements
+// n is the number of elements in array x
+double Sum(double x[], size_t n)
+{
+    double sum = 0.0;
+
+    for (size_t i = 0 ; i < n ; ++i)
+        sum += x[i];
+
+    return sum;
+}
+
+// Function to calculate the average of array elements
+double Average(double x[], size_t n)
+{
+    return Sum(x, n) / n;
+}
+
+// Function to read in data items and store in data array
+// The function returns the number of items stored
+size_t GetData(double *data)
+{
+    size_t nValues = 0;
+    printf("How many values do you want to enter (Maximum %d)? ", MAX_COUNT);
+    scanf_s("%zd", &nValues);
+
+    if (nValues > MAX_COUNT) {
+        printf("Maximum count exceeded. %d items will be read.", MAX_COUNT);
+        nValues = MAX_COUNT;
+    }
+
+    for (size_t i = 0 ; i < nValues ; ++i)
+        scanf_s("%lf", &data[i]);
+
+    return nValues;
+}
+// main program - execution always starts here
+int main(void)
+{
+    double samples[MAX_COUNT] = {0.0};
+    size_t sampleCount = GetData(samples);
+    double average = Average(samples, sampleCount);
+    printf("The average of the values you entered is: %.2lf\n", average);
+    return 0;
+}

Beginning C, 5th Edition/Chapter 08/program8_04.c

@@ -0,0 +1,144 @@
+// Program 8.4 The functional approach to string sorting
+#define __STDC_WANT_LIB_EXT1__ 1
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#define BUF_LEN  256                         // Input buffer length
+#define INIT_NSTR  2                         // Initial number of strings
+#define NSTR_INCR  2                         // Increment to number of strings
+
+char* str_in();                              // Reads a string
+void str_sort(const char**, size_t);         // Sorts an array of strings
+void swap(const char**, const char**);       // Swaps two pointers
+void str_out(const char* const*, size_t);    // Outputs the strings
+void free_memory(char**, size_t);            // Free all heap memory
+
+// Function main - execution starts here
+int main(void)
+{
+    size_t pS_size = INIT_NSTR;                 // count of pS elements
+    char **pS = calloc(pS_size, sizeof(char*)); // Array of string pointers
+    char **pTemp = NULL;                        // Temporary pointer
+    size_t str_count = 0;                       // Number of strings read
+    char *pStr = NULL;                          // String pointer
+    printf("Enter one string per line. Press Enter to end:\n");
+
+    while ((pStr = str_in()) != NULL) {
+        if (str_count == pS_size) {
+            pS_size += NSTR_INCR;
+
+            if (!(pTemp = realloc(pS, pS_size * sizeof(char*)))) {
+                printf("Memory allocation for array of strings failed.\n");
+                return 2;
+            }
+
+            pS = pTemp;
+        }
+
+        pS[str_count++] = pStr;
+    }
+
+    str_sort(pS, str_count);                    // Sort strings
+    str_out(pS, str_count);                     // Output strings
+    free_memory(pS, str_count);                 // Free all heap memory
+    return 0;
+}
+
+/******************************************************************
+ *      String input routine                                      *
+ *  Returns the address of the string or NULL for an empty string.*
+ *  address of the string otherwise.                              *
+ *  Also returns NULL if no memory is obtained or if there is an  *
+ *  error reading from the keyboard.                              *
+ ******************************************************************/
+char* str_in(void)
+{
+    char buf[BUF_LEN];                          // Space to store input string
+
+    if (!gets_s(buf, BUF_LEN)) {                // If NULL returned...
+        // ...end the operation
+        printf("\nError reading string.\n");
+        return NULL;
+    }
+
+    if (buf[0] == '\0')                         // If empty string read...
+        return NULL;                              // ...end the operation
+
+    size_t str_len = strnlen_s(buf, BUF_LEN) + 1;
+    char *pString = malloc(str_len);
+
+    if (!pString) {                             // If no memory allocated...
+        printf("Memory allocation failure.\n");
+        return NULL;                              // ...end the operation
+    }
+
+    strcpy_s(pString, str_len, buf);          // Copy string read to new memory
+    return pString;
+}
+
+/****************************************************
+ *      String sort routine                         *
+ * First argument is array of pointers to constant  *
+ * strings which is of type const char*[].          *
+ * Second argument is the number of elements in the *
+ * pointer array – i.e. the number of strings       *
+ ***************************************************/
+void str_sort(const char **p, size_t n)
+{
+    bool sorted = false;                        // Strings sorted indicator
+
+    while (!sorted) {                           // Loop until there are no swaps
+        sorted = true;                            // Initialize to indicate no swaps
+
+        for (int i = 0 ; i < n - 1 ; ++i) {
+            if (strcmp(p[i], p[i + 1]) > 0) {
+                sorted = false;                       // indicate we are out of order
+                swap(&p[i], &p[i + 1]);               // Swap the string addresses
+            }
+        }
+    }
+}
+
+/******************************************************
+ *      Swap two pointers                             *
+ * The arguments are type 'pointer to pointer to char'*
+ * This is necessary to interchange the two pointers. *
+ ******************************************************/
+
+void swap(const char** p1, const char** p2)
+{
+    const char *pT = *p1;
+    *p1 = *p2;
+    *p2 = pT;
+}
+
+/******************************************************************
+ *      String output routine                                     *
+ * First argument is an array of const pointers to const strings. *
+ * The second argument is  the number of the number of strings.   *
+ ******************************************************************/
+void str_out(const char* const* pStr, size_t n)
+{
+    printf("The sorted strings are:\n");
+
+    for (size_t i = 0 ; i < n ; ++i)
+        printf("%s\n", pStr[i]);                  // Display a string
+}
+
+/********************************************
+ *      Free heap memory                    *
+ * First argument is the array of pointers. *
+ * Second argument is the number of strings *
+ *  in the array.                           *
+ *******************************************/
+void free_memory(char **pS, size_t n)
+{
+    for (size_t i = 0 ; i < n ; ++i) {
+        free(pS[i]);
+        pS[i] = NULL;
+    }
+
+    free(pS);
+    pS = NULL;
+}

Beginning C, 5th Edition/Chapter 08/program8_05.c

@@ -0,0 +1,22 @@
+// Program 8.5 A function to increase your pay
+#include <stdio.h>
+
+long *IncomePlus(long* pPay);          // Prototype for increased pay function
+
+int main(void)
+{
+    long your_pay = 30000L;              // Starting salary
+    long *pold_pay = &your_pay;          // Pointer to pay value
+    long *pnew_pay = NULL;               // Pointer to hold return value
+    pnew_pay = IncomePlus(pold_pay);
+    printf("Old pay = $%ld\n", *pold_pay);
+    printf("   New pay = $%ld\n", *pnew_pay);
+    return 0;
+}
+
+// Definition of function to increment pay
+long* IncomePlus(long *pPay)
+{
+    *pPay += 10000L;                     // Increment the value for pay
+    return pPay;                         // Return the address
+}

Beginning C, 5th Edition/Chapter 08/program8_06.c

@@ -0,0 +1,24 @@
+// Program 8.6 A function to increase your pay that doesn’t
+#include <stdio.h>
+
+long *IncomePlus(long* pPay);          // Prototype for increased pay function
+
+int main(void)
+{
+    long your_pay = 30000L;              // Starting salary
+    long *pold_pay = &your_pay;          // Pointer to pay value
+    long *pnew_pay = NULL;               // Pointer to hold return value
+    pnew_pay = IncomePlus(pold_pay);
+//  printf("Old pay = $%ld\n", *pold_pay);
+//  printf("   New pay = $%ld\n", *pnew_pay);
+    printf("\nOld pay = $%ld   New pay = $%ld\n", *pold_pay, *pnew_pay);
+    return 0;
+}
+
+// Definition of function to increment pay
+long *IncomePlus(long *pPay)
+{
+    long pay = 0;                       // Local variable for the result
+    pay = *pPay + 10000;                // Increment the value for pay
+    return &pay;                        // Return the address of the new pay
+}

Beginning C, 5th Edition/Chapter 09/program9_01.c

@@ -0,0 +1,40 @@
+// Program 9.1 Pointing to functions
+#include <stdio.h>
+
+// Function prototypes
+int sum(int, int);
+int product(int, int);
+int difference(int, int);
+
+int main(void)
+{
+    int a = 10;                         // Initial value for a
+    int b = 5;                          // Initial value for b
+    int result = 0;                     // Storage for results
+    int (*pfun)(int, int);              // Function pointer declaration
+    pfun = sum;                         // Points to function sum()
+    result = pfun(a, b);                // Call sum() through pointer
+    printf("pfun = sum             result = %2d\n", result);
+    pfun = product;                     // Points to function product()
+    result = pfun(a, b);                // Call product() through pointer
+    printf("pfun = product         result = %2d\n", result);
+    pfun = difference;                  // Points to function difference()
+    result = pfun(a, b);                // Call difference() through pointer
+    printf("pfun = difference      result = %2d\n", result);
+    return 0;
+}
+
+int sum(int x, int y)
+{
+    return x + y;
+}
+
+int product(int x, int y)
+{
+    return x * y;
+}
+
+int difference(int x, int y)
+{
+    return x - y;
+}

Beginning C, 5th Edition/Chapter 09/program9_02.c

@@ -0,0 +1,45 @@
+// Program 9.2 Arrays of Pointers to functions
+#include <stdio.h>
+
+// Function prototypes
+int sum(int, int);
+int product(int, int);
+int difference(int, int);
+
+int main(void)
+{
+    int a = 10;                          // Initial value for a
+    int b = 5;                           // Initial value for b
+    int result = 0;                      // Storage for results
+    int (*pfun[3])(int, int);            // Function pointer array declaration
+    // Initialize pointers
+    pfun[0] = sum;
+    pfun[1] = product;
+    pfun[2] = difference;
+
+    // Execute each function pointed to
+    for (int i = 0 ; i < 3 ; ++i) {
+        result = pfun[i](a, b);            // Call the function through a pointer
+        printf("result = %2d\n", result);  // Display the result
+    }
+
+    // Call all three functions through pointers in an expression
+    result = pfun[1](pfun[0](a, b), pfun[2](a, b));
+    printf("The product of the sum and the difference = %2d\n", result);
+    return 0;
+}
+
+int sum(int x, int y)
+{
+    return x + y;
+}
+
+int product(int x, int y)
+{
+    return x * y;
+}
+
+int difference(int x, int y)
+{
+    return x - y;
+}