Testing for TRUE and FALSE; A Problem Scenario

I wish they did better fact checking in these textbooks. Here’s a case in the C Programming book I’m reading. I was having problems with the following code:

FILE* spIn;
spIn = fopen("program73.dat", "r");
if(spIn != NULL)
 {
 printf("Could not open file.\a\n");
 exit(101);
 } // if open fails

Here’s the problem. The line if(spIn != NULL) always exits the program. However, if(!spIn) and if(spIn == NULL) both work fine.

The problem is that he was telling the program to terminate if the file opened successfully, the opposite of what he meant. The file pointer returns NULL if it’s not able to open the file. He told the program to exit if the pointer did not return NULL; in other words, the program terminated every time the file opened successfully. The other two checks I used checked to see if NULL was returned and the program would exit only if the file did not open successfully.

In a textbook, I certainly think the author should compile and test his programs to see if they work correctly a greater extent than this. However, this underscores a common problem for programmers. It’s very easy to get your tests backwards when testing for true and false conditions.

The best rule? Keep it simple and readable. If you have to take time to think through the logic, look for an easier way to write the condition. The second best rule, I guess, is to actually compile and run a program before you include it in a book, just to make sure it works correctly.

Aside | Posted on by | Leave a comment

Dynamically Allocating Memory for an Array

InPursuitYes, I know I haven’t written in a while. I’ve been busy. I decided to go back to college to learn the things I wanted to learn. I would get so far with C, then my eyes would glaze over. So, I’ve been taking 14 hours while working full time, to force myself to learn to code the things my mind typically avoids.

I’m finding that the course material is better for me than the tutorials I find online. One case in point is using malloc to dynamically allocate memory for arrays. This is something I wouldn’t have been able to do before. I’ve been taking C++ at school and it’s making C easier for me to understand. I’m taking the second semester of C++ in the spring, and a C class as well.

Enough of that, let’s create a dynamic array! I’ve taken someone else’s code, that I felt was incomplete, and rewritten it. This program runs fine on Linux. You may want to add #include <conio.h> to the include statements at the beginning if you are using a Microsoft OS.

// first we include the libraries
#include <stdio.h>
#include <stdlib.h>

// everything else, we'll do in main
int main() {
  // declare variables, including
  // array declared as int* array; a pointer
  // initially point it to NULL to avoid potential problems
  // programmers differ on whether the pointer should be type cast
  // a void pointer will return an error if you forget to include
  // the library but type casting makes the code compilable in C++
  int* array = NULL;

  // n will be a user-supplied number
  // i will be used as a counter in the for loop(s)
  int n, i;

  // Ask the user how many elements they want in the array
  printf("Enter the number of elements you want in the array: ");
  scanf("%d", &n);

  // this statement allocates memory for
  // n elements the size of an int
  array = (int*) malloc(n*sizeof(int));

  // check to see if the memory allocation failed
  // if it did, notify the user of the problem
  // and terminate the program with an error
  if(NULL == array)
  {
    puts("\nError allocating memory for array! Terminating!\n");
    return 1;
  }

  // everything's okay, so we'll ask the user to
  // enter a number for each element of the array
  for (i=0; i<n; i++) {
  printf("Enter number %d: ", i);
  scanf("%d", &array[i]);
  }

  // output the array one element at a time
  // then output its size for the user
  printf("\nThe Dynamic Array is: \n");
  for (i=0; i<n; i++) {
  printf("The value of %d is %d\n", i, array[i]);
  }
  printf("Size= %d\n", i);

  // when finished, free the memory that was allocated for the array
  free(array);

  // point the pointer to null
  // so you do not accidentally 
  // try to use it again with
  // unexpected results
  array = NULL;

  // return zero, exiting without errors
  return 0;
}

I thought it pretty strange that one example I saw didn’t show the user how to free the memory after the operation. Also, several didn’t bother setting the array pointer to point at NULL.

Memory is routinely freed once it is no longer in use by the program. If you want your program to run efficiently and cleanly, manually freeing memory that is no longer in use is more than just a good idea. The ability to directly manage memory like this is one of the big reasons to use a lower-level language like C or a mid-level language like C++. Assigning the pointer to NULL after freeing memory assures that you will get an error message if you accidentally try to use the pointer again to access the memory that has been freed.

Speaking of C++, I found the following example of doing the same thing in that language.

// i am not providing the full code here, just snippets

// start by declaring the pointer and initializing it to NULL
// C++ is a strongly typed language, so you must declare the 
// proper type for the array you want to use
int* a = NULL;
  
int n;           // declare the size variable

cin >> n;        // get the size from the user
a = new int[n];  // allocate memory for that number of ints
                 // note the comparative simplicity of the
                 // statement compared to the C statement
// increment through the elements
// put one more than the number of 
// that element in the element 
// will read 1 2 3 ... n when outputting 
for (int i=0; i<n; i++)
{
    a[i] = i+1;
}

// now iterate again, printing each array element
for(int i=0; i<n; i++
{
    cout << a[i] << endl;
}

// finished with the array, now free the memory
delete [] a;

// memory is free, now point the pointer a to NULL
// to prevent accessing the freed memory
a = NULL;

Memory that your program didn’t free will be freed when the program terminates but it’s best to free it manually where appropriate. Never free memory that wasn’t dynamically allocated – the results are unpredictable.

You must specify “[]” when deleting an array, but not for a single value. It isn’t possible
to delete only part of an array. As I mentioned before, setting the pointer to NULL isn’t strictly necessary, but it’s the best practice so that any further use of the pointer will produce an error. Some compilers will take care of that for you when you delete the
pointer but it’s best to do it anyway, just in case.

Posted in Computer/Web/Programming | Tagged , , , | 2 Comments

My Secret to Success

I have a secret. This secret drives everything I do and it is what led me from working an 8 to 5 job to owning a media company. I’m going to share that secret with you right now.

I don’t ask anyone’s permission.
Continue reading

Posted in Business/Politics, Computer/Web/Programming, Entertainment/Media, Philosophy/Religion | Leave a comment

C Programming – Pointer to argc

InPursuitJust for fun, here’s a little program that uses a pointer to return the number of arguments that are submitted to the program at the command line.

#include <stdio.h>

int main(int argc, char argv[])
{
int *ptrArgc;

ptrArgc = &argc;
printf("\n\nOutput number of arguments in argc: %d \n\n", *ptrArgc);

printf("\n\nOutput memory address of argc: %d \n\n", ptrArgc);

return 0;

}

First, notice the line that declares the main() function in the program. The “int argc” declares an integer that automatically fills itself with the number of arguments entered at the command line when you run the program. The name of the program is the first argument, so the smallest number it can return is 1. The “char argv[]” is a character array that contains all the arguments entered at the command line, with “argv[0]” returning the name of the program itself.

The line “int *ptrArgc;” line declares a pointer and the “ptrArgc = &argc;” line assigns the memory address of argc to the pointer.

When printf() is used for the first time, ptrArgc is dereferenced with an asterisk. This causes it to print the value contained in argc instead of the memory address.

The second time printf() is used, ptrArgc is not dereferenced, so it prints the number actually contained in ptrArgc, which is the memory address that holds the value for argc.

Try compiling and running this program, entering different numbers of arguments at the command line. Notice the assigned memory address changes when you run the program.

Posted in Computer/Web/Programming | Tagged , , , , , , , , , | Leave a comment

C Programming – Binary to Decimal Converter

InPursuit

There are 10 kinds of people in this world, those who understand binary and those who don’t. — Unknown

While reading a book on assembly language programming, I came across a section that discussed different numbering systems used and how to convert from one to another. I gave myself some assignments to complete one at a time. Here’s the first one. This converter takes an 8-bit, unsigned binary number, entered at the command line as argv[1], and converts it to its decimal equivalent.

This was a fun assignment. It can easily be modified to take a 16-bit number instead, simply by changing the number of iterations in the for() loop and the starting number for the myCount variable. It uses the pow() function in math.h but everything else in the code is pretty straight forward. I have not tested it fully but it does compile and work using the Visual Studio 2012 command line compiler.

// function receives a string containing an 8-bit, unsigned binary integer 
// returns the decimal integer value of the binary integer
#include <stdio.h>
#include <string.h>
#include <math.h>
int main(int argc, char *argv[])
{
 const char *binNumber = argv[1];
 int decNumber = 0;
 int myDecCount;
 int myCount = 7;

 puts("\n\nBinary to Decimal Converter\nby David Peterson Harvey\n\n");

if (argc == 2)
 {
 printf("%s converts to %d\n\n", binNumber, decNumber);
 // if argv[1] == 8 digits long, binNumber = {argv[1]};
 if(strlen(argv[1]) == 8)
 {
 for(myDecCount=0; myDecCount <=7; myDecCount++) 
 {
 if(binNumber[myCount] == '1')
 {
 decNumber = decNumber + pow(2, myDecCount);
 }
 printf("\nCurrent number %d.\nCurrent count %d.\n\n", myDecCount, decNumber);
 myCount--;
 }
 }
 else
 {
 printf("You must enter a binary number 8 digits long. You entered %s.\n\n", argv[1]);
 }
 }
 else
 {
 printf("To use program:\n\n\t %s 8-digit_binary_number\n\n", argv[0]);
 }
return 0;
}
Posted in Computer/Web/Programming | Tagged , , , , , , | Leave a comment

C – Temperature Conversion

InPursuit I’ve been having fun, reading through a couple of books. One is the second addition of K&R’s “The C Programming Language,” arguably the standard for the C programming language. Early in the book, they provide the reader with a simple conversion table between Fahrenheit and Celsius. I decided it would be fun to take their code a step further and provide a little more functionality to the program. In my spec, I would have the original table generation available but I would also provide functionality to allow the user to enter his or her own temperatures for conversion. The original table provided a one way conversion then displayed the results in a table so the user could reference the table. I had to provide calculations both ways, from Fahrenheit to Celsius and from Celsius to Fahrenheit.

Here’s the original program.

int main()
{
/* print Fahrenheit-Celsius table
for fahr = 0, 20, ..., 300 */
int fahr, celsius;
int lower, upper, step;

lower = 0;
upper = 300;
step = 20;
fahr = lower;

puts("Conversion Table:\n\n");
while(fahr <= upper)
{
celsius = 5 * (fahr-32) / 9;
printf("%d\t%d\n", fahr, celsius);
fahr = fahr + step;
}
}

Here is my version. Notice I used the switch statement, evaluating characters input using getch() to determine what to do. If the user chooses anything except an invalid response or ‘q’ to quit, the appropriate function is called. Also, notice that the user input conversions get the number to convert as a string then convert the number as an int using atoi(). This is not the only way to do a conversion from string to int, nor is it usually considered the best way, since it gives no error reporting, but it is a good, quick and dirty way to do conversions of this type.

This was written and compiled as a console program using Visual Studio Express 2012. It will not compile on Linux systems without a few changes. I have a similarly working version for Linux I will post immediately following. It is not perfect and there’s a quick workaround for a problem using scanf() but it gives a decent look at using switches and functions in Linux C.

#include <stdio.h>
char getDecision()
{
char decision;

system("cls");
puts("\n\nTemperature Converter\n\n");
puts("\t(c) Celsius to Fahrenheit\n\t(f) Fahrenheit to Celsius\n\t(t) Conversion Table\n\t(q) Quit\n\nMake your selection ...\n\n");
decision = getch();

return decision;
}

void displayTable()
{
/* print Fahrenheit-Celsius table
for fahr = 0, 20, ..., 300 */
int fahr, celsius;
int lower, upper, step;

lower = 0;
upper = 300;
step = 20;
fahr = lower;

puts("Conversion Table:\n\n");
while(fahr <= upper)
{
celsius = 5 * (fahr-32) / 9;
printf("%d\t%d\n", fahr, celsius);
fahr = fahr + step;
}
puts("\n");
}

void convertFtoC()
{
char numberString[256];
int celsius, fahr;
// get the number to convert as a string
puts("Converting Fahrenheit to Celsius\n\n");
puts("Enter number to convert ...\n\n");
fgets (numberString, 256, stdin);
// convert the string number to an integer
fahr = atoi(numberString);
// do the calculations
celsius = 5 * (fahr-32) / 9;
// print the results
printf("%d Fahrenheit = %d Celsius\n\n", fahr, celsius);
}

void convertCtoF()
{
char numberString[256];
int celsius, fahr;

// get the number to convert as a string
puts("Converting Celsius to Fahrenheit\n\n");
puts("Enter number to convert ...\n\n");
fgets (numberString, 256, stdin);
// convert the string number to an integer
celsius = atoi(numberString);
// do the calculations
fahr = (celsius * 9) / 5 + 32;
// print the results
printf("%d Celsius = %d Fahrenheit\n\n", celsius, fahr);
}

int main()
{
char decision = 'x';

decision = 'x';

while(decision != 'q')
{
decision = getDecision();

switch(decision)
{
case 'q':
system("cls");
puts("\n\nTemperature Converter\n\n");
puts("Program exited with no errors.\n\n");
exit(0);
break;
case 'c':
convertCtoF();
break;
case 'f':
convertFtoC();
break;
case 't':
displayTable();
break;
default :
puts("Invalid selection.\n\n");
}
puts("\nPress any key to continue ...\n\n");
getch();
}
return 0;

Now, here’s the code that compiles on a Linux machine.

#include <stdio.h> 
#include <stdlib.h> 
 
char getDecision() 
{ 
    char maindecision; 
 
    system("clear"); 
    puts("\n\nTemperature Converter\n\n"); 
    puts("\t(c) Celsius to Fahrenheit\n\t(f) Fahrenheit to Celsius\n\t(t) Conversion Table\n\t(q) Quit\n\nEnter your selection ...\n\n"); 
    maindecision = getchar(); 
 
    return maindecision; 
} 
 
void displayTable() 
{ 
    /* print Fahrenheit-Celsius table 
    for fahr = 0, 20, ..., 300 */ 
    int fahr, celsius; 
    int lower, upper, step; 
 
    lower = 0; 
    upper = 300; 
    step = 20; 
    fahr = lower;             
 
    puts("Conversion Table:\n\n"); 
    while(fahr <= upper) 
    { 
        celsius = 5 * (fahr-32) / 9; 
        printf("%d\t%d\n", fahr, celsius); 
        fahr = fahr + step; 
    } 
    puts("\n"); 
} 
 
void convertFtoC() 
{ 
    char numberString[256]; 
    int celsius, fahr; 
    // get the number to convert as a string 
    system("clear"); 
    puts("Converting Fahrenheit to Celsius\n\n"); 
    puts("Enter degrees Fahrenheit ...\n\n"); 
    // get and process the number 
    if(scanf("%s", numberString)) 
    { 
        // convert the string number to an integer 
        fahr = atoi(numberString); 
        // do the calculations 
        celsius = 5 * (fahr-32) / 9; 
        // print the results 
        printf("\n\n%d Fahrenheit = %d Celsius\n\n", fahr, celsius); 
    } 
    else printf("\n\nIncorrect input received.\n\n"); 
} 
 
void convertCtoF() 
{ 
    char numberString[256]; 
    int celsius, fahr; 
 
    // get the number to convert as a string 
    system("clear"); 
    puts("Converting Celsius to Fahrenheit\n\n"); 
    puts("Enter degrees Celsius ...\n\n"); 
    // get and process the number 
    if(scanf("%s", numberString)) 
    { 
        // convert the string number to an integer 
        celsius = atoi(numberString); 
        // do the calculations 
        fahr = (celsius * 9) / 5 + 32; 
        // print the results 
        printf("\n\n%d Celsius = %d Fahrenheit\n\n", celsius, fahr); 
    } 
    else puts("\n\nIncorrect input received.\n\n"); 
} 
 
int main() 
{ 
    char decision = 'x'; 
 
    decision = 'x'; 
 
    while(decision != 'q') 
    { 
        decision = getDecision(); 
 
        switch(decision) 
        { 
            case 'q': 
                system("clear"); 
                puts("\n\nTemperature Converter\n\n"); 
                puts("Program exited with no errors.\n\n"); 
                exit(0); 
                break; 
            case 'c': 
                convertCtoF(); 
                break; 
            case 'f': 
                convertFtoC(); 
                break; 
            case 't': 
                displayTable(); 
                break; 
            default : 
                puts("Invalid selection.\n\n"); 
        } 
        getchar(); 
        puts("\nEnter to continue ...\n\n"); 
        getchar(); 
    } 
    return 0; 
} 

Posted in Computer/Web/Programming | Tagged , , , , , , , , , , , , , | Leave a comment

C – Hello World!

InPursuitThe first program most people learn to write in any computer language is a program called “Hello World!” An online programmer friend recently mentioned that many of the basics you encounter in the programming language are built into “Hello World!” It got me thinking and I decided to post a short example of this classic program with explanations.

Yes, this program can be found many places and I’m reinventing the wheel by writing it. However, every person explains differently and, where someone else may have confused you, I may be the person to explain something in a way you will understand. Also, I find that communicating concepts helps me understand them better.

Here’s the program in C.

#include <stdio.h>

int main() {

   printf("\n\nHello World!\n\n");
   return 0;

}

The first line we encounter is:

#include <stdio.h>

This instruction is called a pre-processor directive. It loads the standard input/output library into the program. Part of the raw power of C is the low level control it gives you over the tasks your computer accomplishes and a good portion of this power is derived from the functionality that libraries provide. The most basic (and most often used) input and output are the keyboard and monitor, used to input and output data (interact with the program).

Libraries contain pre-programmed functions that expand what you can do with a computer language and “stdio.h” is one of the standard libraries included in the C language. You can also write functions of your own to complete repetitive tasks. In fact, there is one function that every C program must have.

Here’s the function that every C program must have to compile and run.

int main() {

}

Programmers refer to this function as “main.” The “int” refers to the type of data that the function returns when it exits, an integer. Functions are capable of returning different types of data or no data at all. A function that returns no data starts with “void” instead and there are other types. I have seen programs that start “main” with “void” instead of “int” but not all compilers will compile them. It is standard to start “main” with “int” and return an integer when the program exits, using a “return” statement.

The actual function is the word “main,” followed by parentheses and a pair of curly braces. The braces can contain data and commands. You can place data inside the parentheses that you want passed to the function. Our example contains a couple of lines of code inside the braces but the parentheses are empty. That is because we are not passing any outside data to “main.”

Here is an example.

return 0;

The “return” statement is used to return data when the function completes. It’s standard for the “main” function to return a zero when it completes, indicating that the program completed and exited normally. The “;” at the end of the line is like the period at the end of a sentence in English. It notifies the compiler that this is the end of the statement.

The one line of the program we haven’t discussed is:

printf("\n\nHello World!\n\n");

This line calls the “printf” function and tells it to print the “Hello World!” message to stdout, which is usually the computer screen. The printf() is the complete function (you only add the braces to functions in which you are writing the commands), everything between the parentheses is the data you are passing to the function and the semicolon at the end of the line tells the compiler this is the end of the statement.

Everything between the double quotes is a string of characters sent to the “printf” function. You can pass data in other ways but, when you are typing a string of characters to send, you must enclose them in double quotes. The “\n” is a newline character and printf() will respond by moving down a line on your screen before writing the message. In this case, the message is printed two lines down from the command used to call the program and is followed by two more new lines, ensuring that there is space before and after the program’s output. This makes the output more readable because it is not surrounded by clutter.

I hope you enjoyed the article. I’m looking forward to any comments, questions or corrections you may have.

Posted in Computer/Web/Programming | Tagged , , , , , , | 2 Comments