A pointer is a special type of variable in the C programming language that holds the memory address of another variable. The anatomy of a pointer is broken down into three parts, the address of, the assignment, and the dereferencing. First comes the addressing of the pointer. At this stage a pointer is defined within the programming language but currently doen not point to anything. Next comes the assignment of the pointer. In this stage the pointer is is referenced, or given a value to point at in memory. Last comes the dereferencing of the pointer. In this last stage the pointer is called on within the programming code. Because a pointer points to a value in memory, the value is being pointed to is either read out or written too depending on the operation that is taking place.

Below is a sample code of a pointer as found in the C programming language:

Note: A pointer is defined with a astrix before its name. The ampersand before “test” means “address of”, so we have basically said the pointer “link” points to the memory address of “data”.

/*
 * Sample code for a pointer
 */
#include <stdio.h>
 
int main()
{
    int data
    int *link; //On this line the pointer "link" is defined.
 
    *link = &data; //On this line we have set the "link' pointer to "point" to the information stored in "data".
    printf("The integer named "data" contains the value %hhu\n", data);
    printf("The pointer named "link" contains the value %hhu\n", *link);
 
    return(0);

Below is the resulting output of the above code once compiled:

lab46:~$ ./test
The integer named data contains the value 42
The pointer named link contains the value 42
lab46:~$

A “header file” is a file that contains specific elements of a programs code such as commonly used declarations, variables, and other commonly used code into a packaged that is easily distributed and are reusable in other works. Commonly used header files include “stdio.h” which defines a systems standard input and output devices such as the monitor and keyboard, and “stdlib.h” which is a systems general utilities library and handels things like dynamic memory management and random number generation.

Below is a sample of header files being used within the code of a program.

/*
 * Sample code block
 */
#include <stdio.h> // On this line we are including the library "stdio.h" ("stdio" stands for "standard input/output")
#include <stdlib.h> // On this line we are including the library "stdlib.h" ("stdlih" stands for "standard library")
 
int main()
{
    char = *word
    word=(char*)malloc(sizeof(char)*24);
    return(0);
}

Input and output are absoutely necessary in a computer based world. If a computer has no input it has no purpose, and without an output we are unable to tell what the computer has done with the data we fed to it. But what if there is a problem, the computer needs a way to deal with a problem or error within the data that it has been fed. There exists a library, the C Standard Input and Output Library, known as stdio.h in the C language that contains all the necessary information a computer needs to interface with any standard input and output device. This library contains three standard streams, stdin, stdout, and stderr. Stdin handles input such as your keyboard and mouse. Stdout handles output to devices such as a monitor or printer. Stderr handles any error that may occurs and outputs an error message to the standard output device which is normally the monitor. These streams are automatically created and opened for any programs that access the library.

Below is an exmaple of Standard I/O as used in the C language.

/*
 * Sample code block
 */
#include<stdio.h> // This is where the C Standard Input/Output Library is introduced into the program code.
#include<stdlib.h>
 
int main()
{
        int datain=0, *dataout;
        dataout = &datain;
        printf("Please enter a number that is 0 or greater.");
        fscanf(stdin, "%d", &datain); // On this line the program accepts an input from a standard input device, most commonly the keyboard.
        while( datain < 0 )
        {
                fprintf(stderr, "You entered a number less than 0. Try again."); // This line tells the program to output an error message when an invalid value is given. Normally this error is directed to another file but in this case it has been redirected to the screen through the use of the fprintf statement.
                printf("\n");
                printf("\n");
                printf("Please enter a number that is 0 or greater.");
                fscanf(stdin, "%d", &datain);
                printf("\n");
        }
        printf("Your number is %d\n", *dataout); // Here the program outputs a result to the standard output device, most commonly the monitor.
        printf("\n");
        return(0);
}

Below is the output of the above code once compiled and executed:

lab46:~$ ./test
Please enter a number that is 0 or greater.0
Your number is 0

lab46:~$ ./test
Please enter a number that is 0 or greater.-1
You entered a number less than 0. Try again.

Please enter a number that is 0 or greater.1

Your number is 1

lab46:~$

Repetition/Iteration structures are essential in the C programming language. These structures allow for a program to do multiple things without having to be restarted for each new process. There are 3 different types of structures, for, while, and do while, and each of these structures have a different purpose. A “for loop” will loop from one integer to the next while incrementing by specified ammount. A “while loop” can be used to run a process repetitively when the number of times a loop need to run is not known. A “do while loop” is almost the same as a while loop with one exception. After the loop has run once it will test the data to see if we have to continue or end the loop.

Below is an example of a repetition/iteration structure as found in the C programming language.

/*
 * Sample code block
 */
#include<stdio.h>
#include<stdlib.h>
 
int main()
{
        int datain=0, *dataout;
        dataout = &datain;
        printf("Please enter a number that is 0 or greater.");
        fscanf(stdin, "%d", &datain);
        while( datain < 0 ) // this is the beginning of the iteration structure. This iteration structure is a while loop and is designed to loop untill the proper input is given.
        {
                printf("You entered a number less than 0. Try again.");
                printf("\n");
                printf("\n");
                printf("Please enter a number that is 0 or greater.");
                fscanf(stdin, "%d", &datain);
                printf("\n");
        }
        printf("Your number is %d\n", *dataout);
        printf("\n");
        return(0);
}

Below is the output of the above code once compiled and ran:

lab46:~$ ./test
Please enter a number that is 0 or greater.0
Your number is 0

lab46:~$ ./test
Please enter a number that is 0 or greater.-1
You entered a number less than 0. Try again.

Please enter a number that is 0 or greater.1

Your number is 1

lab46:~$

File access in the C programming is the act of a program accessing a file for the purpose of reading the contents of a file, writing data to a new or existing file, or appending data to an existing file.

Below is an example of File access in the C programming language.

#include<stdio.h>
#include<stdlib.h>
 
int main()
 
{
        FILE *in,*out; // Here two file pointers are defined named in and out.
        char value=0;
        in=fopen("file.txt","r"); // Here the file "file.txt" is opened with read permissions.
        out=fopen("out.txt","w"); // Here the file "out.txt" is opened with write permissions.
        if(in==NULL)
        {
                printf("ERROR!\n");
                exit(1);
        }
        fscanf(in,"%hhd",&value);
        while(value!=-1)
        {
                value*=2;
                fprintf(out,"%hhd\n",value); // Here the program writes data to the file "out.txt" via the file pointer "out".
                fscanf(in,"%hhd",&value); // Here the program reads data from the file "file.txt" via the file pointer "in".
        }
        fclose(in); // Here the file "file.txt" is closed via the file pointer "in".
        fclose(out); // Here the file "out.txt" is closed via the file pointer "out".
        return(0);
}

A function in the C programming language is a block of code that has a name and property that are reusable. This means that a function can be called on from as many different points in the program as needed.

A Parameter in the C programming language is any data that is passed to a function.

Below is an example of functions and parameters as found in the C programming language.

#include<stdio.h>
#include<stdlib.h>
 
int sum(int, int, int, int); //This is a function prototype for sum
 
float avg(int, int, int, int); //This is a function prototype for average
 
int main() // This is the "main" function of the program. "Main" defines what the program will actually accomplish when executed.
 
{
        int a=0, b=0, c=0, d=0, max=0, min=0;
 
        printf("Enter first value");
        fscanf(stdin, "%d", &a);
 
        if(a > max)
        {
                max=a;
        }
 
        printf("Enter second value");
        fscanf(stdin, "%d", &b);
 
        if(b > max)
        {
                max=b;
        }
 
        printf("Ented third value");
        fscanf(stdin, "%d", &c);
 
        if(c > max)
        {
                max=c;
        }
 
        printf("Enter fourth value");
        fscanf(stdin, "%d", &d);
 
        if(d > max)
        {
                max=d;
        }
 
        if((a < b)&&(a < c)&&(a < d))
        {
                min=a;
        }
 
        if((b < a)&&(b < c)&&(b < d))
        {
                min=b;
        }
 
        if((c < a)&&(c < b)&&(c < d))
        {
                min=c;
        }
 
        if((d < a)&&(d < b)&&(d < c))
        {
                min=d;
        }
 
        fprintf(stdout, "The sum of %d, %d, %d, and %d is %d\n", a,b,c,d,sum(a,b,c,d));
 
        fprintf(stdout, "The average of %d, %d, %d, and %d is %f\n", a,b,c,d,avg(a,b,c,d));
 
        fprintf(stdout, "The highest value entered is %d\n", max);
 
        fprintf(stdout, "The smallest value entered is %d\n", min);
 
        return(0);
}
 
int sum(int n1, int n2, int n3, int n4) // Here a function named "sum" is defined and the integer parameters n1, n2, n3, and n4 are passed to it. 
 
{
        int total=0;
        total=n1+n2+n3+n4;
        return(total);
}
 
float avg(int n1, int n2, int n3, int n4) // Here another function named "avg" is defined and the integer parameters n1, n2, n3, and n4 are passed to it.
 
{
        float total=0;
        total=(float)(n1+n2+n3+n4)/(4);
        return(total);
}

An array is a collection of memory addresses that all store the same data type of and can be referenced through a common variable name. An array must be declared before they can be used in a program.

Standard notation is the standard syntax used within the C programming language to create or access an array.

Pointer Arithmetic is the method used to access an element or elements of an array.

There are two types of arrays that exist, single-dimensional and multi-dimensional. A single-dimensional array is an array that is organized into one single row or column. A multi-dimensional array is an array that is organized into multiple rows or columns.

Below is an example of arrays as found in the C programming language.

#include<stdio.h>
#include<stdlib.h>
 
int main(int argc, char **argv) // Here **argv is defining a multi-dimensional array. This array is fed from arguments that are entered at the time of the programs execution. 
{
        int datain;
        unsigned char i;
 
        printf("Please enter a value between 0 and 4");
        fscanf(stdin, "%d", &datain);
        while( datain < 0 || datain > 4) 
        {
                printf("You entered a value that is not between 0 and 4. Please try again");
                printf("\n");
                printf("Please enter a value between 0 and 4");
                fscanf(stdin, "%d", &datain);
        }
        for(i=0; i < argc; i++)
        {
                printf("argv[%hhu]: %c\n", i, *(*(argv+i)+datain)); // Here the array is de-referenced through the use of pointer arithmetic and an array element is read based on the result from the arithmetic. Note how the array is referenced as this is the standard notation for working with arrays.
        }
        return(0);
}

Within the C programming language, a variable is a name that is used to refer to a specific point in memory. There are four different types of variables which are int, char, float, and double.

The “int” variable type is used to store integers that are in the form of whole numbers. On a 32 bit computer system an “int” is 32 bits or 32/8 which is 4 bytes length. This means that an “int” has the possibility of storing one of 4294967296 different possibilities.

The “char” variable is capable of holding any member of the character execution set. A char can hold the same kind of data that an “int” can but a char is normally 8 bits or 8/8 which is 1 byte in length.

The “float” variable, short for “floating point” is used to store real numbers. A “float” is only the size of one machine word size which on todays system is typically 32 bits or 32/8 which is 4 bytes in length.

The “double” variable, short for “double floating point” is similar to a normal “float”. While a “float” only allows for the storage of integers a “double” allows for the storage of both integer and non-integer data. The reason its called a “double” is due to the fact that it is double the size of a “float” which makes it 64 bits or 64/8 which is 8 bytes in length.

Demonstration of the chosen keyword.

If you wish to aid your definition with a code sample, you can do so by using a wiki code block, an example follows:

/*
 * Sample code block
 */
#include <stdio.h>
 
int main()
{
    int num=8; // Here an "int" variable is declared and is initialized with the integer number 8.
    char i; // Here a "char" variable named "i" is declared.
    float data; // Here a "float" variable named "data" is declared.
    double input=2x; // Here a "double" variable named "input" is declared and it initialised with a value of 2x.
    return(0);
}

The objective of this course is to learn both the C and C++ programming languages and how to properely utilize them.

This objective entials that a working knowledge of the C and C++ languages will be gained. This includes understading the languges and there proper syntax which includes the usage of pointers and variables, if/then/else statements, memory management, how to compile source code composed of C or C++ language.

Successfull completion of this objective means that I would be able to look at any source code that is written in C or C++ and be able to understand what the program is accomplishing.

Due to the current stage of completion of this course I cannot yet measure this accurately. While I have learned a great deal thus far I am still not at a level where I could say that I have met all of the course objective.

Reflect upon your results of the measurement to ascertain your achievement of the particular course objective.

• At this point in time I do believe I am progressing at a good pace.
• I do believe there is room for improvement but this inprovement will occur with further progression within the course.
• Yes, the measurement could be enhanced to further reflect on many different parts of the course obective.
• I do think this enhancement would be effective to employ and I will be employing this enhancement durring the progression of the course.

Typedef allows a user to define there own identifiers. These new identifiers can be used in place of type specifiers such as int, float, and double. A typedef declaration doesn't allocate any additional storage and the names defined using typedef are not new data types rather they are merely synonyms for the data types they represent. When an object is defined using a typedef identifier, the properties of the defined object are exactly the same as the original data type they represent.

Enum short for “enumerated data”. enums allow a user to define a fixed set of words that a variable of type enum can use as its value. The words are assigned integer values by the compiler so enum values can be compared.

A union is comprised of a collection of variables of different types, just like a structure. However, with unions, you can only store information in one field at a time. Once a new value is assigned to a field, any existing data is overwritten with new data. The use of unions can save memory if you have a grouping of data and only one of the types is used at a time. The size of a union is dependent on the size of it's largest data member.

Type casting also known as type conversion is the concept of converting one data type to another data type. For example you might have a float data type that needs to be an int data type for use in some part of a code.

Below is an example of Type Casting in C.

#include <stdio.h> 
 
int main()       
{
  /* The (char) is a typecast. Its telling the computer to interpret the 32 as a
     character, not as a number.  The output of will be the ASCII equivalent of
     the number 65  (It should be the letter A for ASCII). Note that the %c below
     is the format code for printing a single character
   */
  printf( "%c\n", (char)32 );
  getchar();
}

Scope refers to the way data is declared and accessed within a program.

Global scope, found in C++, occurs when a name is declared outside of all blocks, namespaces, and classes. The name is accessible anywhere after its declaration.

Local scope also know as Block Scope, occurs when a name is declared within a block. The name can be used within the block that it was created in and any child blocks that are enclosed within the parent block.

File scope, found in C, occurs when a name is declared outside all blocks or classes. The name is accessible anywhere after it is declaration.

Below is a demonstration of Scope.

/*
 * Sample code block
 */
#include <stdio.h>
 
void test{int} //This function prototype has file scope because it is defined outside any block, namespace, or class.
 
int main()
{
   int z=0; //This variable has been declared within a block of code this giving this block scope.
 
   return(0);
}

Selection structures also known as control structures are special structures found in the C and C++ programming language. These structures allow for one of multiple possible scenarios to occur based on the value of a variable.

Below is an example of an If structure.

/*
 * Sample code block
 */
#include <stdio.h>
 
int main()
{
    int a;
    int b;
    int c;
 
    if (a > b)
    {
        c = a * b;
    }
    else
    {
        a = b * c;
    }
 
    return(0);
}

Below is an example of a case/switch structure.

/*
 * Sample code block
 */
#include <stdio.h>

int main()
{
    char a;
    char b;
    int c;
    int d;
    
    switch(d)
        {
        
            case 1:
            
                statement;
            
                break;
            
            case 2:
        
                statement;
            
                break;
            
            case 3:
        
                statement;
            
                break;      
                
        }
        
    return(0)
}

Logic can be defined as the non-arithmetic operations performed by a computer, such as sorting, comparing, and matching, that involve true-false decisions.

Operators can be defined as symbols that are used to perform operations. There are 8 logic operators available in the C and C++ programming language and those are !, &&, ||, ^, !=, &=, |=, ^=.

The “!” notates logical “NOT”

The “&&” notates logical “AND”

The “||” notates logical “OR”

The “^” notates logical “XOR”

The “!=” notates logical “NOT_EQ”

The “&=” notates logical “AND_EQ”

The “|=” notates logical “OR_EQ”

The “^=” notates logical “XOR_EQ”

Arithmetic is the portion of mathematics that deals usually with the non-negative real numbers including sometimes the transfinite cardinals and with the application of the operations of addition, subtraction, multiplication, and division to them

Operators can be defined as symbols that are used to perform arithmetic operations.

Below is an example of arithmetic in C along with some of the basic mathematical operators available in the C language.

/*
 * Sample code block
 */
#include <stdio.h>
 
int main()
{
    int a=20;
    int b=5;
    int c=0;
 
    a + b = c; //Add
 
    a - b = c; //Subtract
 
    a * b = c; //Multiply
 
    a / b = c; //Divide
 
    a % b = c; //Modulo(Remainder)
 
    return(0);
}

A structure can be defined as a collection of variables that can be accessed under one variable name thus providing a way to keep related information grouped together.

Below is an example of structures found in the C language.

/*
 * Sample code block
 */
#include <stdio.h>
 
int main()
{
    int t;
 
    struct //This keyword tells the system a structure is being declared.
    {
        char name[30];
        char street[40];
        char city[20];
        char state[3];
        unsigned long int zip;
    } addr_info;
 
    addr_info.zip = 14830; //Here the zip element is accessed and the zip is written to it.
 
    gets(addr_info.name); //This statement passes a character pointer to the beginning of name.
 
    for(t=0; addr_info.name[t]; ++t)
 
    putchar(addr_info.name[t]);
 
    return(0);
}

Namespaces are an optionally named scope. Names can be declared inside a namespace just as you would for a class or an enumeration. You can access names declared inside a namespace in the same manner you access a nested class name by using the scope resolution (::) operator. Namespaces however, do not have the additional features that classes or enumerations possess. The main purpose of namespaces are to add an additional identifier (the name of the namespace) to a name.

Below is an example of namespaces as found in the C++ language.

/*
 * Sample code block
 */
#include <iostream>
using namespace std;
 
namespace primary
{
  int var = 5;
}
 
namespace secondary
{
  double var = 3.1416;
}
 
int main () 
{
 
    cout << primary::var << endl;
 
    cout << secondary::var << endl;
 
    return 0;
}

Compiler - A compiler is a program that can assemble a human readable source code into machine code that a system can execute.

PreProcessor - A preprocessor is a program that performs some sort of preliminary processing on an input before being processed by the main program.

Flags - A flag is a variable or memory location that stores a true-or-false value, normally either recording the fact that an event had occured or a request for a certain action to take place.

Assembler - An assembler is a program that is used to convert instructions written in a low level code into maching code.

Linker - A computer program that adjusts two or more machine language program segiments so they can be loaded simultaneously and executed as one unit.

Multi-file Programs - Multi-file programs are programs that have been broken up into easier to manage blocks of code. Normally functions have there own file and each function has its own header file. This is done to keep code modular and organized. Keeping code modular like this allows for code to be reused elsewhere.

Below is a link to a Mulit-file program I have created. Once you click on the link simply scroll down to the code section of the page. Note how all the functions have there own seperate file.

http://www/user/brobbin4/portfolio/cprogproject3

I/O streams are channels in which data can flow to or from any I/O device. I/O device is a device such as a keyboard, mouse, disk drive, basically anything that can either send input to a system or recieve output from a system.

In C++ an I/O stream can be refered to any data stream that sends data into a program or recieves data from a program.

C++ does not have I/O streams built into the language and instead use the iostream library to provide the necessary information to handel I/O streams. C++ has some basic I/O streams available to it which are cin, cout, cerr.

cin - the C++ standard input cout - the C++ standard output cerr - the C++ standard error handler. This is used when a program ancounters an error and needs a place to send that error information.

Stream operators can be defined as an operator that has an influence on how the data from I/O Streams are handeled.

Type casting operators are operators that are used to change one data type to another data type. The most general cast operator supported by most C++ compilers is “(type) expression” where type is the desired data type.

Const short for constant means something is not modifiable, so data objects that are declared with const as a part their type specifications must not be assigned to in any way during execution of a program. Most of the time the definitions of the objects will contain an initializer because you cannot assign it and if they didn't contain an initializer you would never get a value.

Volatile means something can me modified and we have this type specifier mainly for problems that are encountered in real-time or embedded systems programming using C++. For example you are creating code that will control a hardware device by placing values in hardware registers at known absolute addresses. Because this is happening in real time we need a way to change these values on the fly but most C compilers have not been able to handle this in the past. To correct this issue and other issues that have to do with when to write to where a pointer points the volatile keyword was introduced. This tells a compiler that an object is subject to sudden change for reasons which cannot be predicted from a study of the program itself and this forces every reference to such objects to be a genuine references.

A class is an expanded concept of a data structure. A class is the definition of an object and thus a class can hold not only data but it can hold functions too. Classes resemble structs with one difference, all struct members are public by default where all class members are all private by default.

Objects - objects are components of a program that know how to perform certain actions. Objects also know how to interact with others pieces of a program.

Constructor - A constructor is a member function with the same name as its class. Constructors are called as such because they construct the values of data members of the class. A constructor resembles an instants method but differs from a method because a constructor never has an explicit return type.

Destructor - A destructor is like a constructor is the fact that it is a member function with the same name as its class and that it resembles ans instants method but never has an explicit return value. A destructor is used to deallocate memory and do other cleanup tasks for a class object and its class members when an object is destroyed.

Access Control - C++ employs access control to limit access to certain data within a class. below are the ways that this is accomplished.

Public - members specified within the public section of a class are accessible from any function.

Protected - members specified within the protected section of a class are accessible only by the functions of the class that original declared the members, friends of the class that originally declared the members, classes derived with public or protected access from the class that originally declared the members, and direct privately derived classes that also have private access to protected members.

Private - members specified within the private section of a class are accessible only from member functions and friends of the class.

Friend - A friend allows a function or class to gain access to to the private and protected members of a class in which they are not a member of.

“This” Pointer - “this” pointer is a pointer that is accessible only within the non-static member functions of a class, struct, or union. It points to the member function for which the member function is called.

Inheritance is the mechanism of reusing and extending existing classes without modifying them. Inheritance is kinda like embedding an object into a class. For example, you declare object c of class M in the class definition of R. The result is class R will have access to the public data members and member functions of class M, however in class R you will have to access the data members and member functions of class M through object c. In single inheritance classes have only one base class while in multiple inheritance classes may have multiple base classes.

Polymorphism/Virtual Functions - A key feature of derived classes is that a pointer to a derived class is type-compatible with a pointer to its base class. Polymorphism means that a call to a member function will cause a different function to be executed dependent on the type of object that invokes the function. A virtual function is a function in a base class that is declared using the keyword virtual.

Abstract Base Class - An abstract base class is a base class that contains at least one pure virtual function. A pure virtual function is declared by using a pure specifier in the declaration of a virtual member function in the class declaration.

Overloading is the practice of supplying two or more definitions for a given function name in the same scope. The compiler is left to pick the appropriate version of the function or operator based on the arguments with which it is called.

Functions - Function overloading is the act of declaring more then one function with the same function name in the same scope. The declarations of each function must differ from each other by the types and/or the number of arguments in the argument list. When an overloaded function is called the the correct function is selected through comparison of the argument list of the of the function call with the parameter list of each of the overloaded candidate functions with the same name.

Operators - The operator keyword declares a function specifying what operator-symbol means when applied to instances of a class. This gives the operator more than one meaning, or “overloads” it. The compiler distinguishes between the different meanings of an operator by examining the types of its operands.

Exceptions are run-time anomalies, such as divide by zero, that require immediate handling when encountered. The C++ language provides built-in support for raising and handling exceptions. With C++ exception handling, a program can communicate unexpected events to a higher execution context that is better able to recover from such abnormal events. These exceptions are handled by code that is outside the normal flow of control.

Throw, Try, Catch - these three keyword are the basis of error handling in the C++ language and are defined below.

Throw - A program throws an exception when a problem shows up. This is done using a throw keyword.

Try - A try block identifies a block of code for which particular exceptions will be activated. It's followed by one or more catch blocks.

Catch - A program catches an exception with an exception handler at the place in a program where you want to handle the problem. The catch keyword indicates the catching of an exception.

Templates are mechanisms for generating functions and classes based on type parameters. Through the use of templates, you can design a single class or function that operates on data of many types, instead of having to create a separate class for each type.

STL - The STL or Standard Template Library is a collection of C++ libraries that allow the use of several well known kinds of data structures without having to program them. The templates are designed to efficiently run code. The compiler does most of the work of generating the efficient implementations of the templates.