Lessons In Coding

Passing An Array to Functions in C & C++

2012-04-05T13:50:00.000-04:00

The previous entry looked at various ways to pass a variable to a function: by value, by reference or by pointer. This entry looks at passing an array to a function. In C/C++ arrays are passed by reference or by pointer, not by value. This means the called function can directly change the array as passed by the caller. You can however pass one element of an array by value in the same way you pass an integer or other data type.

The sample code calls a function, CapFirstLetter, which takes a character array from the caller and raises the first letter of each word to uppercase.

The character array is created by:

char Text[] = "Some words to cap.";

I can then define the function signature in one of two ways: with or without a pointer.

int CapFirstLetter(char vText[]);

int CapFirstLetter(char * vText);

The code inside the function is the same.

I can then call the function in one of three ways:

CapFirstLetter(Text);

CapFirstLetter(&Text[0]);

char * pText = &Text[0];

char * pText = Text;

CapFirstLetter(pText);

The critical point to remember is that using the name of the array, in this case, Text, is actually a pointer to the first element of the array. Thus, using Text is the same as using &Text[0] and a pointer can be assigned using either method. The result is the same.

Sample Code.

// Standard I/O library.

#include <cstdio>

// Prototypes.

int CapFirstLetter(char vText[]);

int CapFirstLetter2(char * vText);

int main()

{

printf("Call Function To Cap First Letter of Every Word\n\n");

/////////////////////////////////////////////////////////////////

// 1. Pass array by array name.

printf("1. Pass array by array name.\n\n");

char Text[] = "Some words to cap.";

CapFirstLetter(Text);

printf("Version 1: %s\n", Text);

// The name of the array is a pointer to first element.

char Text2[] = " This function handles extra spaces.";

CapFirstLetter(&Text2[0]);

printf("Version 2: %s\n\n\n", Text2);

/////////////////////////////////////////////////////////////////

// 2. Pass array by pointer variable.

printf("2. Pass array by pointer variable.\n\n");

// Create pointer.

char Text3[] = "a statement with all lowercase letters";

// Option 1.

// The name of the array, Text3, is a pointer to Text3[0].

// char * pText = Text3;

// Option 2.

// Another way to get the address of the first element.

char * pText = &Text3[0];

CapFirstLetter(pText);

printf("Version 3: %s\n", Text3);

// Start later in the array.

char Text4[] = "a statement with all lowercase letters";

pText = &Text4[2];

CapFirstLetter(pText);

printf("Version 4: %s\n", Text4);

// Close the file.

fclose(stdout);

// Return something.

return 0;

}

int CapFirstLetter(char vText[])

{

/////////////////////////////////////////////////////////////////

// Capitalize first letter of a string of text.

short i;

bool PrevSpace = true;

for (i = 0; vText[i]; i++)

{

// Look to find start of new word.

if (PrevSpace)

{

// Ignore space.

if (vText[i] == ' ')

// Go to next char.

continue;

// Not a space, reset flag.

PrevSpace = false;

// Want lowercase only.

if ((vText[i] >= 97) && (vText[i] <= 122))

{

// Appy uppercase.

vText[i] -= 32;

}

else

{

// Start of new word.

if (vText[i] == ' ')

// Reset.

PrevSpace = true;

}

// Return success.

return 0;

}

Output.

Passing Data to Functions in C & C++

2012-04-04T11:04:00.000-04:00

C and C++ are built on functions. All programs in C/C++ start with a main() function and branch out from there to other functions. Generally, since it's considered poor coding practice to use global variables, you will need a way to pass local variables from one function to another. This blog looks at the different way of passing data to a function.

1. Pass By Value.

The default in C/C++ is to pass the value of a variable to a function. This means the function cannot change the value of the variable in the caller function. Here is some test code to show this point.

int i = 10;

printf("Pass Argument by Value.\n");

printf("Value before function call: %d.\n", i);

ByVal(i);

printf("Value after function call: %d.\n", i);

void ByVal(int Parameter)

{

// Change won't happen.

Parameter = 100;

printf("Value in function: %d.\n", Parameter);

}

>Pass Argument by Value.

>Value before function call: 10.

>Value in function: 100.

>Value after function call: 10.

When a variable is passed to a function by value, the language copies the value to the heap—the dynamic runtime memory. The variable in the caller function is thus duplicated—one copy in the caller function and one copy for the called function. This is not an efficient use of resources. It uses up memory and it takes time to copy the data. A better way is to pass a memory address of the variable to the called function.

2. Pass By Reference.

If I declare MyVar as integer type, I can find out its memory address with the & operator. The first method of passing a memory address to a variable uses this operator. I define the function with a parameter of DataType &VariableName.

i = 20;

printf("\nPass Argument by Reference.\n");

printf("Value before function call: %d.\n", i);

printf("Address of i in main: %#X.\n", &i);

ByRef(i);

printf("Value after function call: %d.\n", i);

void ByRef(int &Parameter)

{

// Value changes.

Parameter = 200;

printf("Value in function: %d.\n", Parameter);

printf("Address of Parameter in function: %#X.\n", &Parameter);

}

>Pass Argument by Reference.

>Value before function call: 20.

>Address of i in main: 0X36EB8C.

>Value in fn: 200.

>Address of Parameter in function: 0X36EB8C.

>Value after function call: 200.

Because the function ByRef function has direct reference to the i variable, it can change the value. You will note the memory address is the same inside the function as it is in the caller function.

3. Pass By Pointer.

The previous example indirectly passed the memory address for the parameter with ByRef(i) instead of ByRef(&i). The function used the & operator. In this example, the caller must pass a pointer—a direct reference to the memory location. The end result is the same.

int* pi = &i;

i = 30;

printf("\nPass Argument by Pointer.\n");

printf("Value before function call: %d.\n", i);

printf("Address of i in main: %#X.\n", pi);

ByPointer(pi);

printf("Value after function call: %d.\n", *pi);

void ByPointer(int* Parameter)

{

// Value changes.

*Parameter = 300;

printf("Value in function: %d.\n", *Parameter);

printf("Address of Parameter in function: %#X.\n", Parameter);

}

>Pass Argument by Pointer.

>Value before function call: 30.

>Address of i in main: 0X36EB8C.

>Value in fn: 300.

>Address of Parameter in function: 0X36EB8C.

>Value after function call: 300.

Calling the function with a pointer, ByPointer(pi), is equivalent to this: ByPointer(&i).

These examples used the integer data type. The code could be modified to use the other built-in data types: char, bool, double, float. For passing an array, especially a character array, to a function, see the next blog entry.

The freopen Functions in C & C++

2012-04-03T06:15:00.000-04:00

The freopen Function.

The freopen function in the C Standard I/O library <cstdio> is a useful to redirect output destined for the stdout to a text file. I discussed how to use the fprintf function to send output to either a text file or the stdout. See here. The same result is achieved here using the printf and freopen functions.

Method 1.

freopen(Filename, "w", stdout);

There is no return value to indicate if the file was opened or if there was an error.

Method 2.

iReturn = freopen(Filename, "w", stdout);

On failure, a null pointer is returned otherwise the return value is a pointer to the file. Beyond testing for an error, this return value is used to close the file.

fclose(iReturn);

While my example uses the stdout, the freopen function can be used with the stdin and stderr objects.

Test Code.

I tested the functions in Visual C++ 2010 as an console application.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

int main()

{

//**************************************************************

// Redirect stdout to a file.

// Declare pointer to the file.

FILE* pFileHandle;

char Filename[] = "MyFile.txt";

// Returns null is the open failed.

pFileHandle = freopen(Filename, "w", stdout);

printf("pFileHandle is %X.\n\n", pFileHandle);

//**************************************************************

// Header.

printf("Using freopen in C & C++\n\n");

//**************************************************************

// Some use of printf.

printf("Sending the printf output to a file instead of the stdout.\n");

printf("The freopen function allows for this redirection.\n\n");

// Use variable for a string.

char * Text = "A text string only from a variable.\n\n";

printf("%s", Text);

// Int type.

int Salary = 375000;

int Bonus = -35000;

printf("Salary is: %8d.\n", Salary);

printf("Bonus is: %8d.\n", Bonus);

printf("\n");

//**************************************************************

// Close the file.

fclose(pFileHandle);

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

Output.

The printf Function in C & C++

2012-04-02T09:36:00.000-04:00

The printf Function.

The printf function in the C Standard I/O library <cstdio> is a useful and versatile way to send output to the stdout. Your output is a string that may include formatted variable values. The most basic form doesn't use any variables, such as:

printf("This output is a text string only. No variables.\n");

>This output is a text string only. No variable.

The next step is to include a variable as part of the output. For example,

char * Text = "A text string only from a variable.\n";

printf("%s", Text);

>A text string only from a variable.

The code %s is a format specifier for a character array or string. The %s is replaced by the value of Text. This principle applies to other data types. A decimal integer uses %d or %i.

int Salary = 375000;

printf("Salary is: %d.\n", Salary);

printf("Salary is: %i.\n", Salary);

>Salary is: 375000.

The definition of the specifier is:

%[flags][width][.precision][length]specifier

The square brackets means the parameter is optional. Hence, the most basic specifier is % followed by a letter of: c, d, i, e, E, f, g, G, o, s, u, x, X, p, or n.

This blog will go through examples of these specifiers and the various parameters. Once you understand the printf function, you can apply this knowledge in using the fprintf, fscanf, scanf, sprintf, sscanf functions.

Integer Data Types.

There are three specifiers for the integer data type in decimal format (Base 10). %d and %i apply to signed integers. %u applies to unsigned integers. If you use %u with a signed integer, the output will be garbage.

Salary = -35000;

printf("Using it with a negative value: %u doesn't work.\n\n", Salary);

>Using it with a negative value: 4294932296 doesn't work.

You can use an unsigned integer with %d or %i.

unsigned ActNum = 1234;

printf("Unsigned variable works with %%i or %%d. ActNum is %i.\n\n", ActNum);

>Unsigned variable works with %i or %d. ActNum is 1234.

Width.

You specify the width the value takes up by adding a number such as %8d or %8i. Setting a width allows you to align numbers.

int Salary = 12345678;

int Bonus = 52000;

printf("Salary is: %8d.\n", Salary);

printf("Bonus is: %8d.\n", Bonus);

>Salary is: 12345678.

>Bonus is: 52000.

If the number is larger than the width, the amount will be displayed, but the alignment will be askew.

int Salary = 1234567890;

int Bonus = 52000;

printf("Salary is: %8d.\n", Salary);

printf("Bonus is: %8d.\n", Bonus);

>Salary is: 1234567890.

>Bonus is: 52000.

Alignment.

The default is to align numbers to the right. You can add a minus sign such as %-8d to specify left alignment.

printf("Salary is: %-8d.\n", Salary);

printf("Bonus is: %-8d.\n\n", Bonus);

>Salary is: 375000 .

>Bonus is: 52000 .

Decimal. Hexadecimal. Octal.

To output a hexadecimal numbers use %x (lowercase) or %X (uppercase). An octal can be outputted with %o. It's the lowercase letter o for octal, not zero. See more examples here.

int num = 65535;

printf("Decimal: %d Hexadecimal: %X Octal: %o \n", num, num, num);

printf("Hexadecimal Uppercase: %X Lowercase: %x \n", num, num);

>Decimal: 65535 Hexadecimal: FFFF Octal: 177777

>Hexadecimal Uppercase: FFFF Lowercase: ffff

Use '#' to add a hex or octal notation prefix.

printf("Use # to create hexadecimal prefix '0X' or '0x'. Such as %#X, %#x.\n", num, num);

>Use # to create hexadecimal prefix '0X' or '0x'. Such as 0XFFFF, 0xffff.

printf("Use # to prefix octal with 0. Such as %#o.\n", num);

>Use # to prefix octal with 0. Such as 0177777.

int * pNum = &num;

printf("It works with pointers. Such as %#X, %#x.\n\n", pNum, pNum);

>It works with pointers. Such as 0X34EDD8, 0x34edd8.

Floating-point Numbers.

Floating point numbers use the f specifier such as %f.

float irrational = 123.456789;

double irrational2 = 123.456789;

printf("Default: %f \n", irrational);

printf("Default: %f \n", irrational2);

>Default: 123.456787

>Default: 123.456789

Set shorter decimal points.

printf("4 decimal points: %.4f \n", irrational);

printf("4 decimal points: %.4f \n", irrational2);

>4 decimal points: 123.4568

Set longer decimal points.

printf("14 decimal points: %.14f \n", irrational);

printf("14 decimal points: %.14f \n", irrational2);

>14 decimal points: 123.45678710937500

>14 decimal points: 123.45678900000000

Plus or Minus.

The flag + will show a plus sign or minus sign before a number.

Salary = 375000;

Bonus = -27500,

printf("Salary and bonus: %+d, %+d.\n", Salary, Bonus);

>Salary and bonus: +375000, -27500.

Padding With Zeroes.

The flag 0 (zero) places zeroes in front of a number. It only applies if a width has been specified.

Salary = 375000;

Bonus = 27500,

printf("Salary is: %08d.\n", Salary);

printf("Bonus is: %08d.\n", Bonus);

printf("Salary is: %0d.\n", Salary);

>Salary is: 00375000.

>Bonus is: 00027500.

>Salary is: 375000.

Scientific Notation.

Use %e or %E with a floating point number to display it in scientific notation. A number is formatted as: x.xxxxxxEnnn. The decimal equivalent is x.xxxxxx multiplied by 10 to the power of nnn.

double Notation = 100;

printf("100 is: %E.\n", Notation);

> 100 is: 1.000000E+002.

In base 10, a number greater than zero has 1s, 10s, 100s etc. So, 100 is 1 one-hundred. A common mistake happens when a number is less than zero. 0.001 is not 1/100 but 1/1000. So, 0.1 is tenths, 0.01 is hundreds, 0.001 thousands and so on.

Notation = 1.0/100.0;

printf("1/100 is: %f or %E.\n", Notation, Notation);

> 1/100 is: 0.010000 or 1.000000E-002.

double LargeNum = 123456789123;

printf("Number using E: %E.\n", LargeNum);

printf("Number using e: %e.\n", LargeNum);

>Number using E: 1.234568E+011.

>Number using e: 1.234568e+011.

printf("Specify width: %15E.\n", LargeNum);

printf("Specify decimals: %.2E.\n", LargeNum);

>Specify width: 1.234568E+011.

>Specify decimals: 1.23E+011.

double SmallNum = 0.123456789123;

printf("Number using E: %E.\n", SmallNum);

>Number using E: 1.234568E-001.

The scientific notation doesn't work with integer data types.

int Num = 100;

printf("Doesn't work with integers: %E.\n", Num);

>Doesn't work with integers: 5.820601E-308.

Using stdin & stdout in C & C++

2012-03-28T19:03:00.000-04:00

Normally if I wanted to send some data to the screen (the console or stdout), I'd use the printf function. Here's an example.

printf("There are %d polar bears outside your window.", BearCount);

It works great. And if I wanted to send the same information to a file, I would use the fprintf function. It works the same way except you must specify a file to use. Such as:

// Declare pointer to the file.

FILE* pFileHandle;

// Saves the file in the EXE folder.

char Filename[] = "MyFile.txt";

// Open file for writing.

pFileHandle = fopen(Filename, "w");

// Write data to file.

fprintf(pFileHandle , "("There really are %d polar bears outside your window.\n\n", BearCount);

// Close the file.

int iReturn = 0;

iReturn = fclose(pFileHandle);

What if I wanted to send the data to the screen or a file or both? While the standard I/O library creates a type FILE for handling files, it also creates the objects stdin and stdout. I can use the same fprintf function in both cases and write code to change the value of pFileHandle.

For a file,

pFileHandle = fopen(…

but for the screen use:

pFileHandle = stdout;

fprintf(pFileHandle , "Print some data to a text file.\n\n");

fprintf(stdout, "Print some data to stdout.\n\n");

The same principle applies to reading data from a file or from the keyboard (i.e., stdin). I can use the fgets function for either.

From a file with,

fgets(Text, num, pFileHandle);

or from the standard input:

fgets(Text, num, stdin);

Data to a maximum length of num is stored in the character array Text.

The reason for doing this should be obvious. You can easily switch between a file or standard I/O without repeating your code.

Test Code.

I tested the functions in Visual C++ 2010 as an console application.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

// Function prototypes.

int DataOut(FILE* pFile);

int DataIn(FILE* pFile, char* text);

// Max length of text input.

const int MAXLEN = 80;

int main()

{

// Using stdin & stdout in C & C++

// Header.

printf("Using stdin & stdout instead of a File\n\n\n");

// Output.

printf("***** OUTPUT *****\n\n");

// Declare pointer to the file.

FILE* pFileHandle;

// Saves the file in the EXE folder.

char Filename[] = "MyFile.txt";

// Open file.

pFileHandle = fopen(Filename, "w");

// Write data to file.

DataOut(pFileHandle);

// Close the file.

int iReturn = 0;

iReturn = fclose(pFileHandle);

// Do the same but send to stdout.

DataOut(stdout);

printf("\n\n");

// Input.

printf("***** INPUT *****\n\n");

// Declarations.

char readline[MAXLEN];

// Open file.

pFileHandle = fopen(Filename, "r");

// Get data.

DataIn(pFileHandle, readline);

// Close the file.

iReturn = fclose(pFileHandle);

printf("From the file: %s\n", readline);

printf("Input with fgets: ");

// Get data.

pFileHandle = stdin;

DataIn(pFileHandle, readline);

// OR DataIn(stdin, readline);

printf("Your input: %s\n", readline);

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

int DataOut(FILE* pFile)

{

// Code to send data to file or screen.

fprintf(pFile, "Print some data to a text file or to the screen.\n\n");

return 0;

}

int DataIn(FILE* pFile, char* text)

{

// Code to send data to file or screen.

fgets(text, MAXLEN, pFile);

return 0;

}

Output.

The fprintf Function in C & C++

2012-03-27T15:33:00.000-04:00

You can open a text or binary file with fopen and close it with fclose. (See here.) The fprintf function allows you to “print” data to a text file. It is similar to the printf function except the output goes to a file instead of the standard output.

A note on text files versus binary files. If you open a text file with an editor program, chances are you can read and make some sense of what’s there. Not so with a binary file. The binary file is raw data in the way variables stored in memory are raw data—binary data. But text files store binary data as well, but along the way, it’s converted to a human readable form using an ASCII table or Unicode character set. So while you may write “Hello World” to a text file and see it as such, it is being converted to some binary code.

Back to the fprintf function. The same code explains it.

Test Code.

I tested the functions in Visual C++ 2010 as an console application.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

int main()

{

// Header.

printf("\"Print\" Data To A Text File\n\n");

// Pointer to the file.

FILE* pFileHandle;

// Puts the file in the project path.

char Filename[] = "MyFile.txt";

// Version 1.

// w attribute for writing to the file.

// If the file does not exist, it is created.

// Any existing file content is overwritten.

printf("File attribute: w - (over) write\n");

pFileHandle = fopen(Filename, "w");

// Write data to file.

fprintf(pFileHandle , "\"Print\" Data To A Text File\n\n");

fprintf(pFileHandle , "Writing some data to a text file.\n");

fprintf(pFileHandle , "Any existing data in the file is lost.\n");

// Close the file.

int iReturn = 0;

iReturn = fclose(pFileHandle);

// Version 2.

// a attribute for appending to the file.

// If the file does not exist, it is created.

// Any existing file content remains.

printf("File attribute: a - appending\n");

pFileHandle = fopen(Filename, "a");

// Write data to file.

fprintf(pFileHandle , "With appending mode, text is added to the file.\n");

// Close the file.

iReturn = fclose(pFileHandle);

// Version 3.

// What happens when you try to write data to a file opened for reading.

printf("File attribute: r - reading\n");

pFileHandle = fopen(Filename, "r");

// Write data to file.

fprintf(pFileHandle , "With reading mode, text isn't added to the file.\n");

// There is no run-time error or compile error.

// Close the file.

iReturn = fclose(pFileHandle);

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

Text File.

A Common Error In C & C++

2012-03-26T18:01:00.000-04:00

In C and C++ there’s a difference between the = assignment operator and the == logical equality operator. In many other languages, the equal sign is used in both situations; therefore, it’s easy to use = when you want to use ==.

You compiler won’t tap you on the shoulder to tell you made a mistake. It will happily chug along. There is no syntax error. The problem happens when you run the program. Besides, assigning the value to the variable, I tested some code to see what would happen.

Take this scenario.

int a = 0;

if (a = 1){…

First the program will assign 1 to a then it will evaluate the expression a as being non-zero (i.e., not false) and execute any code for the true condition.

This code

if (a = 0){…

assigns zero to a and results in a false condition.

Similar events happen with the do and while loops.

How about a for loop like this?

for (i = 0; a = i; ++i) {…

Since a equals i equals 0, it’s false and the for loop doesn’t execute any code under its control.

On the other hand, this code,

for (i = 1; a = i; ++i) {…

creates an infinite loop. Be ready to hit break.

It’s the easiest mistake to make in C and C++ especially if you’re working with other languages at the same time.

Modulus With Negative Numbers in C & C++

2012-03-25T19:59:00.000-04:00

What it is correct answer when calculating the modulus of two numbers when one of the numbers is negative? When it comes to computers, the answer is: it depends.

The starting point is basic division of integers. Take a dividend, a, and divide it by the divisor, b, to get some result that is a quotient, q, and a remainder, r, if any. The modulus of a and b is the remainder, r. This division theorem works for all numbers that are integers, provided b is not zero.

If the a and b have the same sign (both positive or both negative), the quotient is positive. If their signs are opposite (one negative, one positive), the quotient is negative. What about the modulus? It’s easy to think the same process applies, but does it? No.

To calculate r, use the division equation for known values of a, b and q.

The following code in Visual C++ 2010 shows the four different possibilities pos+/neg- values for a and b.

// Header.

printf("Modulus With Negative Numbers\n\n");

printf("a x b = q + r OR b x q + r = a\n\n");

int a = 7;

int b = 2;

printf("a = %d, b = %d \n", a, b);

printf("q: %d / %d = %d \n", a, b, a / b);

printf("r: %d mod %d = %d \n", a, b, a % b);

// 2 x 3 + 1 = 7

printf("%d x %d + %d = %d \n\n", b, a / b, a % b, a);

a = -7;

b = 2;

printf("a = %d, b = %d \n", a, b);

printf("q: %d / %d = %d \n", a, b, a / b);

printf("r: %d mod %d = %d \n", a, b, a % b);

// 2 x -3 - 1 = -7

printf("%d x %d + %d = %d \n\n", b, a / b, a % b, a);

a = 7;

b = -2;

printf("a = %d, b = %d \n", a, b);

printf("q: %d / %d = %d \n", a, b, a / b);

printf("r: %d mod %d = %d \n", a, b, a % b);

// -2 x -3 + 1 = 7

printf("%d x %d + %d = %d \n\n", b, a / b, a % b, a);

a = -7;

b = -2;

printf("a = %d, b = %d \n", a, b);

printf("q: %d / %d = %d \n", a, b, a / b);

printf("r: %d mod %d = %d \n", a, b, a % b);

// -2 x 3 - 1 = -7

printf("%d x %d + %d = %d \n\n", b, a / b, a % b, a);

Output.

You will get the same results in Visual Basic.

When it comes to using the modulus operator, test it with a range of expected parameters to make sure it gives the result you expect and want. Not all versions of C or C++ or other languages behave the same. If all else fails, create your own modulus function to work the way you want.

The fopen and fclose Functions in C & C++

2012-03-24T19:49:00.000-04:00

The cstdio library provides two functions for opening and closing a text file: fopen, fclose. Both functions use a FILE type pointer variable. The FILE type is defined in the library.

The fopen function requires a filename and a tag to specify the mode of access (read, write, append etc.) It returns a handle for accessing the file. The fclose function closes the file associated with the handle.

The first step is to create a pointer of the FILE type.

FILE * pFileHandle;

You open a text file for reading with this code:

pFileHandle = fopen("Filename", "r");

If the file does not exist, the functions returns NULL, otherwise it holds a handle for the opened file.

The file mode, “w” opens a file for writing. If the file does not exist, it is created. If the file exists, any existing data is overwritten.

pFileHandle = fopen("Filename", "w");

Finally, you can use the “a’ tag to append to a file. If the file does not exist, it is created. If the file exists, data is added to the end of the file.

pFileHandle = fopen("Filename", "a");

While it’s possible to close a file this way,

fclose(pFileHandle);

You should confirm the close function worked by analyzing the return value such as:

int iReturn = 0;

iReturn = fclose(pFileHandle);

If the return value is EOF, there was an error closing the file, otherwise the file was closed.

Test Code.

I tested the functions in Visual C++ 2010 as an console application.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

// C++ math library.

#include <cmath>

int main()

{

// Header.

printf("File Open, File Close.\n");

printf("For text files.\n\n");

// Pointer to the file.

FILE* pFileHandle;

// Puts the file in the project path.

char Filename[] = "MyFile.txt";

// Version 1.

// r attribute for reading the file.

// Fails to open if the file does not exist.

printf("File attribute: r\n");

pFileHandle = fopen(Filename, "r");

if (pFileHandle != NULL)

printf("File exists.\n");

else

printf("File doesn't exist.\n");

printf("File Handle: %X \n\n", pFileHandle);

// Version 2.

// w attribute for writing to the file.

// If the file does not exist, it is created.

// Any existing file content is overwritten.

printf("File attribute: w\n");

pFileHandle = fopen(Filename, "w");

if (pFileHandle != NULL)

printf("File exists.\n");

else

printf("File doesn't exist.\n");

printf("File Handle: %X \n\n", pFileHandle);

// Version 3.

// a attribute for appending to the file.

// If the file does not exist, it is created.

// Any existing file content remains.

printf("File attribute: a\n");

pFileHandle = fopen(Filename, "a");

if (pFileHandle != NULL)

printf("File exists.\n");

else

printf("File doesn't exist.\n");

printf("File Handle: %X \n\n", pFileHandle);

// Close the file.

int iReturn = 0;

iReturn = fclose(pFileHandle);

// iReturn = 0 or false, means success closing the file.

// iReturn = EOF means an error.

if (iReturn == EOF)

printf("Error closing the file.\n");

else

printf("File closed.\n");

printf("File Handle: %X \n\n", pFileHandle);

// Return some value.

return 0;

} // end main

Output.

Using XOR To Encrypt Message

2012-03-23T19:23:00.000-04:00

The XOR logic operator provides a convenient way to encrypt a message. By encrypt I refer to the technique where a letter of a readable message is substituted with another letter to make the encrypted message unreadable. At least at first glance.

The basic algorithm to encrypt a message is

message letter XOR key letter = encrypted letter

and to decrypt it’s:

encrypted letter XOR key letter = message letter.

Using the XOR operator with the same key results in symmetry for encrypting and decrypting. To understand that, take a closer look at what happens at the bit level.

I want to encrypt the letter A with the key letter of K.

A is 0x41 or 0100 0001 and K is 0x4B or 0100 1011.

A 0100 0001

K 0100 1011

XOR 0000 1010

So my encrypted letter is 0x0A. Given that value and my key of K, I can run the same process to get the message back.

Ct 0000 1010

K 0100 1011

XOR 0100 0001

Why does it work? Look at the four possibilities:

A xor K = Ct xor K = A

1 1 0 1 1

1 0 1 0 1

0 1 1 1 0

0 0 0 0 0

For each of the four possibilities, using XOR with the same key value brings you back to the original message.

Here is some sample code in C/C++.

// The standard library includes the system function.

#include <cstdlib>

int main()

{

printf("Encrypt Message Using XOR\n\n");

char msg = 'A';

char key = 'K';

char crypto;

// Encipher.

crypto = msg ^ key;

printf("XOR of msg (%X) and key (%X) results in %X.\n\n", msg, key, crypto);

// Decipher.

msg = crypto ^ key;

printf("XOR of crypto (%X) and key (%X) results in %X.\n\n", crypto, key, msg);

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

Output.

Mouse Over To Activate A Window in Windows 7

2012-03-23T14:07:00.000-04:00

For a while now I’ve been using a computer with Windows 7 and there was one behaviour that was driving me nuts. If I opened up a window that didn’t fill the screen, say using Notepad to view a text file, within seconds, the window would disappear. The window below it would now come to the front. To avoid this problem, I had to quickly move the mouse over the new window before it would disappear and more times than not, it would disappear.

I never had this problem with other versions of Windows. There had to be some setting to change the behaviour. You’d think it had something to do with the appearance settings, but no. It’s in the mouse settings.

From the Control Panel, click on “Ease of Access.”

Then click on “Change how your mouse works.”

You can toggle “Activate a window by hovering over it with the mouse.” When it’s enabled, mousing over a window will bring it to the front. When it’s off, mousing away from your current window won’t cause it to lose focus. That’s how I want it and problem solved.

Using Logarithms

2012-03-17T12:55:00.000-04:00

I was watching a documentary on the history of modern computers and came across a few interesting items. I say modern computers because prior to the 1940s, a computer was a person, not a thing. He, primarily, was a person who computed numbers hours after hour. It wasn’t necessarily accounting figures, but anything, like artillery tables, navigational guides, or census statistics. Lots and lots of numbers. Numbers computed without aid of any mechanical devices.

If they wanted to add up a series of numbers, they had to add them up. If they wanted to multiply two numbers, they would consult tables to find the natural logarithmic of the numbers, add those numbers then find that sum in another table to give you the multiplied value. Every step of the process was an opportunity to create an error including the values in the tables. These books of tables were after all created by humans and contained errors. Imagine trying to copy out a telephone book by hand and not make a mistake.

Sometime in the 19^th century Charles Babbage had the idea of creating a machine to eliminate the human error these computers created. It’s suggested his initial concept was the start of computers we know today. Perhaps. One of his difficulties was his choice to use the decimal numbering system instead of binary. Perhaps it wasn’t a choice, just standard operating procedure. Not thinking outside the box. If he had worked on a binary system, he may have built the prototype he had in mind.

And those tables? Here is an example. Say I want to know what 3.3 times 4.4 is because those are the dimensions of some object. I could do the multiplication by hand, double check my figures and report the result. What if I had to do that fifty times in a day? Or more? Look for a faster approach.

The natural logarithm of 3.3 is 1.19392247 and for 4.4, it’s 1.48160454. These log numbers come from a table. As with most people, I can add those numbers together faster than I can multiply them. The result is 2.67552701. Now I find what e to that number is and I come up with 14.52 which is 3.3 times 4.4.

So,

e^{(ln A + ln B)} = A x B

The same works for division.

e^{(ln A - ln B)} = A / B

I haven’t figured out how slide rulers work. No need, just curious.

The tanh Function in C & C++

2012-03-17T09:26:00.001-04:00

More functions from the <math.h> or <cmath> header files. Today it’s about the tanh function.

The tanh function returns the hyperbolic tangent for any real number and is defined as shown below.

From C11 standard.

The newest standard includes the atanh function, but it is not implemented in Visual C++ 2010; however, you can use the log function to determine the arc hyperbolic tangent.

Test Code.

I tested the functions in Visual C++ 2010 as an console application.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

// C++ math library.

#include <cmath>

int main()

{

// Header.

printf("The tanh Function in C & C++\n\n");

printf("Given x, any real number, the function returns y \n");

printf("equal to the hyperbolic tangent of x.\n\n");

// Counter for loop.

int i;

// Argument.

double x;

// Result.

double y, y2;

printf(" x => tanh(x) = (exp(2*x) - 1.0) / (exp(2*x) + 1.0) \n\n");

for (i = -5; i <= 5; ++i)

{

x = i * 1.0;

y = tanh(x);

y2 = (exp(2*x) - 1.0) / (exp(2*x) + 1.0);

printf ("%6.1f => %8.4f = %8.4f\n", x, y, y2);

}

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

Output.

The cosh Function in C & C++

2012-03-16T05:58:00.000-04:00

More functions from the <math.h> or <cmath> header files. Today it’s about the cosh function.

The cosh function returns the hyperbolic cosine for any real number and is defined as shown below.

From C11 standard.

The newest standard includes the acosh function, but it is not implemented in Visual C++ 2010; however, you can use the log function to determine the arc hyperbolic cosine.

Test Code.

I tested the functions in Visual C++ 2010 as an console application.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

// C++ math library.

#include <cmath>

int main()

{

// Header.

printf("The cosh Function in C & C++\n\n");

printf("Given x, any real number, the function returns y \n");

printf("equal to the hyperbolic cosine of x.\n\n");

// Counter for loop.

int i;

// Argument.

double x;

// Result.

double y, y2;

printf(" x => cosh(x) = 0.5 * (exp(x) + 1.0/exp(x)) \n\n");

for (i = -5; i <= 5; ++i)

{

x = i * 1.0;

y = cosh(x);

y2 = 0.5 * (exp(x) + 1.0/exp(x));

printf ("%6.1f => %8.4f = %8.4f\n", x, y, y2);

}

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

Output.

The sinh Function in C & C++

2012-03-13T23:33:00.000-04:00

More functions from the <math.h> or <cmath> header files. Today it’s about the sinh function.

The sinh function returns the hyperbolic sine for any real number and is defined as shown below.

From C11 standard.

The newest standard includes the asinh function, but it is not implemented in Visual C++ 2010; however, you can use the log function to determine the arc hyperbolic sine.

Test Code.

I tested the functions in Visual C++ 2010 as an console application.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

// C++ math library.

#include <cmath>

int main()

{

// Header.

printf("The sinh Function in C & C++\n\n");

printf("Given x, any real number, the function returns y \n");

printf("equal to the hyperbolic sine of x.\n\n");

// Counter for loop.

int i;

// Argument.

double x;

// Result.

double y, y2;

printf(" x => sinh(x) = 0.5 * (exp(x) - 1.0/exp(x)) \n\n");

for (i = -5; i <= 5; ++i)

{

x = i * 1.0;

y = sinh(x);

y2 = 0.5 * (exp(x) - 1.0/exp(x));

printf ("%6.1f => %8.4f = %8.4f\n", x, y, y2);

}

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

Output.

The sqrt Function in C & C++

2012-03-13T05:32:00.000-04:00

More functions from the <math.h> or <cmath> header files. Today it’s about the sqrt function.

The sqrt function is straightforward. Given values for x, the function returns y, the square root.

From C11 standard.

Test Code.

I tested the functions in Visual C++ 2010 as an console application.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

// C++ math library.

#include <cmath>

int main()

{

// Header.

printf("The sqrt Function in C & C++\n\n");

printf("Given x, the function returns y equal to the square root of x.\n\n");

// Counter for loop.

int i;

// Argument.

double n;

// Result.

double y;

printf(" y x y = x\n\n");

for (i = 1; i < 10; ++i)

{

n = 12.3456 / i;

y = sqrt(n);

printf ("%5.4f x %5.4f = %6.4f\n", y, y, n);

}

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

Output.

The pow Function in C & C++

2012-03-12T03:22:00.000-04:00

More functions from the <math.h> or <cmath> header files. Today it’s about the pow function.

The pow function is straightforward. Given values for x and n, the function returns x to the nth power.

From C11 standard.

Test Code.

I tested the functions in Visual C++ 2010 as an console application.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

// C++ math library.

#include <cmath>

int main()

{

// Header.

printf("The pow Function in C & C++\n\n");

printf("Given x and n, the function returns x to the nth power.\n\n");

// Counter for loop.

int i;

// Argument.

double x, n;

// Result.

double y;

printf(" y = x ^ n\n\n");

for (i = 1; i < 10; ++i)

{

x = 12.3456 / i;

n = i;

y = pow(x, n);

printf ("%5.2f = %6.3f ^ %1.0f\n", y, x, n);

}

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

Output.

The frexp Function in C & C++

2012-03-11T11:33:00.000-04:00

More functions from the <math.h> or <cmath> header files. Today it’s about the frexp function.

Given a floating point value a, the function returns S and n such that a = S x 2ⁿ.

The value of S is limited to a range of greater than or equal to 0.5 and less than 1.

The value of n is an integer and is returned by way of a pointer.

From C11 standard.

Test Code.

I tested the functions in Visual C++ 2010 as an console application.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

// C++ math library.

#include <cmath>

int main()

{

// Header.

printf("The frexp Function in C & C++\n\n");

printf("Given a, the function returns S and n\n");

printf("such that a = S x 2 to the nth power.\n\n");

// Counter for loop.

int i;

// Return value, significant.

double S;

// Arugment.

double a;

// 2 to the Nth power.

int n = 0;

printf("a = S x 2 ^ n\n\n");

for (i = 10; i < 27; ++i)

{

a = i / 10.0;

S = frexp(a, &n);

printf ("%4.3f = %4.3f x 2 ^ %d\n", a, S, n);

}

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

Output.

The ldexp Function in C & C++

2012-03-09T21:34:00.000-05:00

More functions from the <math.h> or <cmath> header files. Today it’s about the ldexp function.

Given two values for a and n, the function returns y such that y = a x 2ⁿ.

From C11 standard.

Test Code.

I tested the functions in Visual C++ 2010 as an console application.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

// C++ math library.

#include <cmath>

int main()

{

// Header.

printf("The ldexp Function in C & C++\n\n");

printf("Given a and n, the function returns\n");

printf("a x 2 to the nth power.\n\n");

int i;

printf(" a x 2 ^ n\n\n");

for (i = 0; i < 16; ++i)

printf("10 x 2 ^ %2d = %8.2f\n", i, ldexp(10.0, i));

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

Output.

The fmod Function in C & C++

2012-03-09T04:40:00.000-05:00

More functions from the <math.h> or <cmath> header files. Today it’s about the fmod function.

The modulus operator, %, returns the remainder of a over b. For example, 5 % 2 = 1 since 4, a multiple of 2, plus 1, the remainder, equals 5. The modulus operator however can only be used with whole numbers. The fmod function applies the same principle to floating-point numbers.

From C11 standard.

Test Code.

I tested the functions in Visual C++ 2010 as an console application.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

// C++ math library.

#include <cmath>

int main()

{

// Header.

printf("fmod Function\n\n");

printf("x = fmod(a,b) \n\n\n");

printf("Integer Modulus\n");

printf("5 %% 2 = %d", 5 % 2);

printf("\n\nFloating-point Modulus\n");

printf("modf(5.3, 2) = %6.3f\t", fmod(5.3, 2.0));

printf("\n\n");

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

Output.

The modf Function in C & C++

2012-03-09T02:06:00.000-05:00

More functions from the <math.h> or <cmath> header files. Today it’s about the modf function.

This function returns two values. To do that, one part is returned by way of assignment (e.g., R1 = fn). The second part is return by storing the value in the second argument. (e.g., R1 = f(a,R2). It accomplishes this by using pointers.

The modf function takes a floating point number, e.g., a.b, and breaks the two apart such that R1 = b and R2 = a. R2 is the fractional part. R1 is the integral part.

From C11 standard.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

// C++ math library.

#include <cmath>

int main()

{

// Header.

printf("modf Function\n\n");

printf("R1 = modf(a,R2) \n\n");

double R1, R2;

double a = 123.456;

R1 = modf(a, &R2);

printf("a = 123.456 R1 = %6.3f\tR2 = %3.f\n\n", R1, R2);

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

Output.

The Base 10 Log Function in C & C++

2012-03-06T20:35:00.000-05:00

I am making may way through all the different functions in the various standard header files that form part of C and C++. I’m still working on the contents of the <math.h> or <cmath> header files. Today is about the base 10 logarithmic function.

Say, ten, raised to the power of x, is N then the base 10 log of N is x. Example, 10 squared is 100. The base 10 log of 100 is 2 since 10 to the 2 is 100.

The exp() and log() functions are related since the return value of one can be passed to the other in a circle. There is no sister function for log10(), you have to use the power function with base 10.

Here is a snippet from the C standard (C11 N1570).

What does a domain error mean? First, it only occurs in relation to the functions in the math library. Second, it means you passed an argument to the function which is outside of the range of arguments allowed. The log10 function only allows numbers greater than zero.

From subclause 7.12.1 of the C11 standard:

For all functions, a domain error occurs if an input argument is outside the domain over which the mathematical function is defined. The description of each function lists any required domain errors; an implementation may define additional domain errors, provided that such errors are consistent with the mathematical definition of the function.

The return value for a domain error is dependent on the compiler. In Visual C++ 2010, the return value is -1.#IND000000000000. I suspect the IND stands for indeterminate. Try a google search on that return value.

A pole error indicates the return value approaches zero or positive or negative infinity under the limit functions in calculus. The implement of a pole error is compiler dependent and in Visual C++ 2010, the return value is -1.#INF000000000000 or negative infinity.

Passing a non-positive argument to the function does not result in a compile or run-time error. It’s up to the programmer to ensure proper argument values are passed to the function.

Test Code.

I tested the functions in Visual C++ 2010 as an console application.

Interestingly, I discovered something about the printf function. It prints out zeros when there is a mismatch between a format specifier and the argument. I used “%d” with a float variable and “%f” with other floats. In all cases zero was displayed even when there variables weren’t zero. More on that in another blog, but once I matched them, it worked properly.

// The standard library includes the system function.

#include <cstdlib>

// C++ standard I/O library.

#include <cstdio>

// C++ math library.

#include <cmath>

int main()

{

// Header.

printf("Logarithmic Base 10 Function\n\n");

printf("\tn\t log10(n)\t10^log10((n)) \n\n");

// Counter.

int i;

// Argument.

double n;

for (i = 0; i < 8; ++i)

{

n = pow(10.0, i);

printf("%9.0f\t%10.4f\t%10.0f\n", n, log10(n), pow(10.0,log10(n)));

}

printf("\n\n");

// Negative argument.

printf("Negative argument: %f ", log10(-1.0));

printf("\n\n");

// Zero value argument.

printf("Zero value argument: %f ", log10(0.0));

printf("\n\n");

// Keep console window open.

system("pause");

// Return some value.

return 0;

} // end main

Output.

Backslash Line Splicing in C & C++

2012-03-06T16:57:00.000-05:00

I was playing around with some code in Visual C++ 2010 and at one point I typed a backslash key. The result surprised me.

Here’s an example of what I had:

// Some comment about main function.

int main()

{

Here’s what happened when I added a backslash at the end of the comment.

// Some comment about main function.\

int main()

{

The int main function turned green meaning it was commented. The program wouldn’t compile. I got this error message: error C2447: '{' : missing function header

What was going on?

If I removed the backslash, everything was fine. If I added other characters after the backslash, everything was fine. It had nothing to do with the backslash used in escape sequences and the reference material on adding comments to C or C++ code didn’t discuss a backslash, it was the slash character.

A quick search or two revealed the answer in something called line splicing.

In Appendix A.12 of K&R they write:

Each occurrence of a backslash character \ followed by a newline is deleted, this splices lines.

When you compile your source files, the compiler executes a pre-processing stage where comments are removed and lines with the backslash and newline characters are deleted.

Another lesson learnt in the world of coding.

Summary of Log Functions in C & C++

2012-03-05T17:58:00.000-05:00

The following is a summary of logs functions in C and C++. <math.h> library in C, <cmath> in C++.

C++ overloads the functions for different data types.

e to the nth power

In C

double exp(double)

float expf(float)

long double expl(long double)

In C++

double | float | long exp(double | float | long)

Natural Logarithm

In C

double log(double)

float logf(float)

long double logl(long double)

In C++

double | float | long log(double | float | long)

Base 10 Log

In C

double log10(double)

float log10f(float)

long double log10l(long double)

In C++

double | float | long log10(double | float | long)

C11 / C+11 Standards

The most recent updates to the language standards introduce several new log functions. None are implemented in Visual C++ 2010.

Here’s the list.

exp2 raise 2 to the nth power

log 2 companion to exp2

expm1 is exp(n) – 1 with more precision

logm1 log(n+1) with more precision

Summary of Trig Functions in C & C++

2012-03-05T17:20:00.001-05:00

The following is a summary of trig functions in C and C++. <math.h> library in C, <cmath> in C++.

C++ overloads the functions for different data types.

Sine & Arcsine Functions:

In C

double sin(double)

float sinf(float)

long double sinl(long double)

double asin(double)

float asinf(float)

long double asinl(long double)

In C++

double | float | long sin(double | float | long)

double | float | long asin(double | float | long)

Cosine & Arccosine Functions:

In C

double cos(double)

float cosf(float)

long double cosl(long double)

double acos(double)

float acosf(float)

long double acos(long double)

In C++

double | float | long cos(double | float | long)

double | float | long acos(double | float | long)

Tangent & Arctangent Functions:

In C

double tan(double)

float tanf(float)

long double tanl(long double)

double atan(double)

float atanf(float)

long double atanf(long double)

In C++

double | float | long tan(double | float | long)

double | float | long atan(double | float | long)

Hyperbolic Trig Functions:

In C

double sinh(double)

float sinhf(float)

long double sinhl(long double)

double cosh(double)

float coshf(float)

long double coshl(long double)

double tanh(double)

float tanhf(float)

long double tanhl(long double)

double asinh(double)

float asinhf(float)

long double asinhl(long double)

double acosh(double)

float acoshf(float)

long double acosh(long double)

double atanh(double)

float atanhf(float)

long double atanhf(long double)

In C++

double | float | long sinh(double | float | long)

double | float | long cosh(double | float | long)

double | float | long tanh(double | float | long)

The C++11 standard brings in asinh, acosh, & atanh. These functions aren’t implemented in Visual C++ 2010.