LIST FOR C/C++ KEYWORDS

The following is a list of the major topics being covered in this course:

DONE: Standard I/O (STDIO, STDOUT, STDERR)
DONE: Header Files (Local and System), C Standard Library (Libc), Libraries
DONE: arithmetic (equations, operators)
DONE: logic and operators (and, or, not, xor)
DONE: Variables (types, ranges, sizes)
DONE: Scope (Block, Local, Global, File)
DONE: Pointers (address of, assignment, dereferencing)
DONE: Type Casting
DONE: Selection Structures (if, case/switch)
DONE: Repetition/Iteration Structures (for, while, do while)
DONE: Arrays (standard notation, pointer arithmetic, single-dimensional, multi-dimensional)
DONE: File Access (Read, Write, Append)
Structures (Declaration, Accessing Elements, Pointers to)
typedef, enum, union
DONE: Functions, Parameters (Pass by: Value, Address, Reference), Return Types, Recursion, Command-line arguments
DONE: Compiler, Preprocessor, Flags, Assembler, Linker, Multi-file programs (how to structure, how to compile)
DONE: I/O Streams (cin, cout, cerr, stream operators) [C++]
DONE: Namespaces [C++]
DONE: Type Casting Operators, Const-Volatility Specifiers (const, volatile) [C++]
DONE: Classes (Objects, Constructor, Destructor, Access Control, Public, Protected, Private, Friend, “this” pointer) [C++]
DONE: Inheritance (single, multiple Inheritance), Polymorphism/Virtual Functions, Abstract Base Class [C++]
DONE: Overloading (Functions, Operators) [C++]
Exception Handing (throw, try, catch) [C++]
DONE: Templates, STL (Standard Template Library) [C++]

Repetition/Iteration Structures are basically the coding that is necessary if you want to repeat a process many times, or to count. If you wanted to input 500 values into an array, you'd have to use a repetitive structure (the alternative being typing 500 lines of code). Or let's say you want to run a process multiple times, but each time something is slightly different, you'd use a repetitive structure.

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:

Using a for loop

 
//THIS PROGRAM WILL COUNT FROM 0-20
 
#include <stdio.h>
#include <stdlib.h>
 
 
int main()
{//START MAIN
 
        int count = 0;          //DECLARING AND INITIALIZING A VARIABLE FOR COUNTING
 
 
        for(count; count<=20; ++count)          //FOR LOOP TO COUNT FROM 0-20
        {
                printf("%u sheep.\n", count);   //FSTREAM # AND SHEEP
        }       //END FOR LOOP
 
        return (0);     //RETURN 0
}//END MAIN

Using a do while loop

#include <stdio.h>
 
int main()
{
 
        int count=0;
        do
        {
                printf("%u sheep.\n", count);
                ++count;
        }
        while(count<=20);
 
        return (0);
}

Using a while loop

#include <stdio.h>
 
int main()
{
        int count = 0;
 
        while(count<=20)
        {
                printf("%u sheep.\n", count);
                ++count;
        }
 
        return 0;
}

The outputs of all of these programs lead to the SAME THING, so I'm only putting it once.

lab46:~/src/cprog/MessingAround$ nano RepetitiveDoWhile.c
lab46:~/src/cprog/MessingAround$ gcc -o RepetitiveDoWhile RepetitiveDoWhile.c
lab46:~/src/cprog/MessingAround$ ./RepetitiveDoWhile
0 sheep.
1 sheep.
2 sheep.
3 sheep.
4 sheep.
5 sheep.
6 sheep.
7 sheep.
8 sheep.
9 sheep.
10 sheep.
11 sheep.
12 sheep.
13 sheep.
14 sheep.
15 sheep.
16 sheep.
17 sheep.
18 sheep.
19 sheep.
20 sheep.

Variables are structures that can hold types of data that can be manipulated.

To define a variable you have to make a statement in the code.

[type][identifier] = [value];

The type is the type of variable - Char short int int long int long long int float double long double

All of these variables can also be signed or unsigned (whether or not half of the memory allocated to each variable will be used for negative values, or further positive values.)

The sizes and ranges of these variables can differ, as shown by the output of a program (Project 0) that prints it all.

An unsigned char is 1 bytes
The range of an unsigned char is 0 to 255
An unsigned char can store 255 unique values

An unsigned short int is 2 bytes
The range of an unsigned short int is 0 to 65535
An unsigned short int can store 65535 unique values

An unsigned int is 4 bytes
The range of an unsigned int is 0 to 4294967295
An unsigned int can store 4294967295 unique values

An unsigned long int is 8 bytes
The range of an unsigned long int is 0 to 18446744073709551615
An unsigned long int can store 18446744073709551615 unique values

An unsigned long long int is 8 bytes
The range of an unsigned long long int is 0 to 18446744073709551615
An unsigned long long int can store 18446744073709551615 unique values

A signed char is 1 bytes
The range of a signed char is -128 to 127
A signed char can store 256 unique values

A signed short int is 2 bytes
The range of a signed short int is -32768 to 32767
A signed short int can store 65536 unique values

A signed int is 4 bytes
The range of a signed int is -2147483648 to 2147483647
A signed int can store 4294967296 unique values

A signed long int is 8 bytes
The range of a signed long int is -9223372036854775807 to 9223372036854775806
A signed long can store 18446744073709551615 unique values

A signed long long int is 8 bytes
The range of a signed long long int is -9223372036854775807 to 9223372036854775806
A signed long long can store 18446744073709551615 unique values

A pointer is basically a variable, that contains the address/location of another variable.

To assign a pointer, you denote it with;

*[variable declaration];

The asterisk denotes pointer. And you can have two, or even three to designate a double or triple pointer.

To dereference a pointer, you use an asterisk again.

I think of a pointer as 'going higher' and then dereferencing as 'going back down'.

So if you have a variable called pointer, which is a single pointer, that variable is one level up. To put something in it, you have to bring it down a level.

The plain variable is just the address of where the actual value is being stored.

So, given the following code and output, you can see that the normal variable you can just printf it normally. But when it comes to storing and printing to the pointer, you need to dereference it to take the pointer back down to the storage unit that it specifies.

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
        int *pointer, variable;
 
        *pointer = 9001;        //need  to dereference to store it
 
        variable = 1111;        //not a pointer so it's fine
 
        printf("\nVariable is %d\n", variable);
 
        printf("\nPointer is %d\n", pointer);   
//Since it is not dereferenced, it will print an address (garbage).
 
 
        printf("\n*Pointer (dereferenced) is %d\n", *pointer);
//Since it has been dereferenced, it will properly display the value.
 
        return (0);
 
}

lab46:~/src/cprog/MessingAround$ ./pointers

Variable is 1111

Pointer is -1584842064

*Pointer (dereferenced) is 9001

File Access is basically the term for when you read from, write to, or append a file. Basically the program can open a .txt file or a .data file or whatever, and then either read information from it (such as a list of numbers or something) or write information to it (such as results of some calculation), or append (just add onto what is already in the file).

The following program will take an input file, and then add 1 to every number in the input file, and write those results into a different file.

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
 
        int number;
 
        FILE *in, *out;
//Defines two file variable pointers called in and out.
 
        in = fopen("numbers.txt", "r");
//Opening the input file (known as numbers.txt). The r denotes reading.
 
        out = fopen("output.txt", "w");
//Opening the output file (naming it output.txt). The w denotes writing.
 
        if(in == NULL)
        {
                printf("Error, need an input file numbers.txt");
                exit(1);
        }
//This block checks to make sure that a file gets thrown into the in variable
 
        fscanf(in, "%hhd", &number);
//That in at the beginning of the statement indicates that input file
 
        while(number != 17)
        {
                int newnumber=0;
 
                newnumber = number+1;
 
                fprintf(out, "%hhd\n", newnumber);
 
                fscanf(in, "%hhd", &number);
        }
 
        return (0);
}

Standard I/O is the Default Input, Output, and Error Output. Normally these are the keyboard, and the monitor.

When we use scanf(“%d”, &number); it inputs an integer value from the standard input, which is the keyboard.

If we use fscanf(in, “%d”, &number); it inputs an integer value from whatever is defined as 'in' (like a text file), so we changed the input.

When we use printf(“Hello”); it prints Hello to the standard output, which is the monitor.

If we use fprintf(out, “Hello”); it prints Hello to whatever output is defined by 'out' (for instance, a text file). So we changed the output.

The errors are outputted to the STDOUT typically, and we haven't covered redirecting them in C yet.

An array is basically a bunch of different data values (of the same type) that fall under the same identifier. The identifier is basically a gigantic data block, that has been sliced into smaller blocks, each of which holds the different data values.

This program will use two 1-d arrays, and 1 2-d array. It will store 0-4 in the 1-d arrays, and in the 2-d array it shows examples of counting by increasing numbers in sets of 5. So, in the first one it counts forward by zeros. In the second set it counts forward by 1s. Third by 2s. Etc.

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
        int Array[5];
 //This defines an array that can hold 5 values
 
 
        int D_Array[5][5];
//This defines a 2-d array, so it holds 5 values, each of which have five values underneath (like a table of sorts).
 
        int *P_Array;
        P_Array = (int*)malloc(sizeof(int)*5);
//This defines a 5 slot array, but using pointer style arithmetic.
 
        int count = 0;
        int count2 = 0;
        int number = 0;
 
        for(count = 0; count < 5; ++count)
        {
                int number2 = 0;
 
                Array[count] = number;
 
                *(P_Array + count) = number;
 
                for(count2 = 0; count2 < 5; ++count2)
                {
 
                        D_Array[count][count2] = number*number2;
                        ++number2;
                }
                ++number;
        }
 
 
        printf("\nThe values in Array\n");
 
        for(count = 0; count < 5; ++count)
        {
                printf("%d ", Array[count]);
        }
 
        printf("\nThe values in P_Array\n");
 
        for(count = 0; count < 5; ++count)
        {
                printf("%d ", *(P_Array + count));
        }
 
        printf("\nThe values in D_Array\n");
 
        for(count = 0; count <5; ++count)
        {
                for(count2 = 0; count2 < 5; ++count2)
                {
                        printf("%d ", D_Array[count][count2]);
                }
 
                printf("\n");
        }
 
        printf("\n");
 
        return (0);
}

lab46:~/src/cprog/MessingAround$ vim arrays.c
lab46:~/src/cprog/MessingAround$ gcc -o arrays arrays.c
lab46:~/src/cprog/MessingAround$ ./arrays

The values in Array
0 1 2 3 4
The values in P_Array
0 1 2 3 4
The values in D_Array
0 0 0 0 0
0 1 2 3 4
0 2 4 6 8
0 3 6 9 12
0 4 8 12 16

lab46:~/src/cprog/MessingAround$

Selection structures are basically ways of checking. They allow you to check things within the program, and decide what to do based on the check. With more complex logic operating behind the checks, the more interactive and 'intelligent' the program becomes.

The following program will take a number, and using if blocks determine IF the number is even or odd.

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
        int number = 0;
        int x;
 
        printf("Enter a number: ");
 
        scanf("%d", &number);
 
        x = number%2;
 
        if(x == 0)
        {
                printf("\n%d is even\n", number);
        }
        else
        {
                printf("\n%d is odd\n", number);
        }
        return (0);
}

lab46:~/src/cprog/MessingAround$ vim Selection.c
lab46:~/src/cprog/MessingAround$ gcc -o Selection Selection.c
lab46:~/src/cprog/MessingAround$ ./Selection
Enter a number: 2

2 is even
lab46:~/src/cprog/MessingAround$ ./Selection
Enter a number: 3

3 is odd

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
        int number;
 
        printf("Enter a number: ");
        scanf("%d", &number);
 
        int x;
        x = number%2;
 
        switch (x)
        {
        case 0:
                printf("The number is even");
                break;
        case 1:
                printf("The number is odd");
                break;
        default:
                printf("The number is neither even nor odd");
                break;
        }
 
        printf("\n");
 
        return (0);
}

lab46:~/src/cprog/MessingAround$ gcc -o SwitchCase SwitchCase.c
lab46:~/src/cprog/MessingAround$ ./SwitchCase
Enter a number: 6
The number is even
lab46:~/src/cprog/MessingAround$ ./SwitchCase
Enter a number: 9
The number is odd
lab46:~/src/cprog/MessingAround$ 

Logic and operators allow you to make a program much more interactive and capable.

And can be used to ensure two values are both true.

Or can be used to ensure at least one value is true.

Not returns the opposite of a value , from true to false and vice versa.

XOR will return true if JUST ONE value is true.

Use pointers and variables to discover the indirect properties of data storage

Basically this means that we will figure out, and be able to utilize, pointers and variables for the sake of different methods and 'tricks' behind data storage.

Probably paying attention when Matt Haas is talking about those things would be a great start. Defining these as keywords would help as well.

I defined them both as keywords, and it did help me understand a lot more. I already knew variables for the most part, but all the stuff to do with pointers I was sketchy on and now I feel much more confident about it.

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

I think I did great. Of course there is room for improvement, but I am no longer clueless. Not really, being forced to define them and give working examples of them (for me) works very well. Perhaps the course objective would make a little more sense if it went into a little bit more detail in what it means by 'indirect properties data storage'.

Type casting is basically telling the program to treat a certain entity (an int, char, whatever) using the rules of a different one.

So if we use…

int a = 3; int b = 5;

int c = a/b;

c is actually zero, because of integer division. But if we use this line instead….

int c; (float)c = a/b;

The (float) is a type cast to c, telling the program to treat c as a float, which would ensure that it stores a 0.6 instead of a 0.

Needs #include <iostream>

cout produces output ~ printf cin provides input ~ scanf cerr is just the error output stream operators are things such as setf() and setw() which held you do different things with the stream.

int a=1 int b=2

printf(“a is %d, b is %d\n”, a, b); cout « “a is ” « a « “,b is ” « b « endl;

scanf(“%d”, %a); cin » a;

cerr « “Error, yo” « endl;

Stream operator in use: cout « setw(5) « a « “ sheep are sleeping.” « endl;

Header files are basically files that contain class and function 'prototypes'. It basically will let the program know that there is a class or function which is named something, and the types of parameters and return type it has. Local Header files are the ones that tend to be user made, or could get pulled in from another source I suppose. System header files are the ones that are in the system.

The C Standard Library has a bunch of the most common and useful C header files I would guess, such as stdio for input and output capabilities.

Libraries in C contain all of these functions and whatnot in them.

To call a system header

#include <stdio>

To call a local header

#include “nor.h”

Arithmetic is the way that we can manipulate data. Equations would set some value equal to something else, while operators can compare values.

To assign a value to a variable using an equation:

Density = 50*8/13;

To compare using an operator:

if (Density < 100)
{
    printf("Wow")
}

Scope is basically the region of the program in which a declared variable will exist. Block would mean the scope is in regards to the set of brackets you're in. Local would mean within a function. Global would mean within an entire file of code. File would (I assume) mean between files. Although how to do this I do not know.

if( x>3)
{
    int Q = 5;   // Q only exists within this if statement
}
 
int Sum1(int num1, int num2)   //these two integers are only defined within this function!
{
    return (num1 + num2)
}
 
int x;     //this variable will be defined throughout the entire file, regardless of functions and whatnot.
int main()
{
    x = 4
}

Functions are basically isolate segments of code that can do certain things based on Parameters that you pass them. It saves a lot of coding, for example, to have a function that you just send different values of length and width to calculate the area of 50 squares is much easier than actually writing the code to do 50 different areas.
Return Types are the variable type that the function will be returning- in the case of the area function, we would probably want to return a float value.
Recursion is basically when a function calls itself within itself, with some end terminating condition. We haven't covered it in class yet though.
Command-line arguments are when you pass parameters to the main function of the program.

There are some great examples of functions in Project 1 and Project 2. Everything is used except Recursion.

Overloading a function is to use the same function name for multiple functions, with the difference being the parameters passed to the function.

Let's say we want to write a program that will calculate areas. Rectangles, Squares, and Circles. We'll overload a function to do this.

int Area(int);    //for the square
float Area(float, float);   //for the rectangle
float Area(float);    //for the circle

These functions will actually work, and depending on the parameters that we send, it will either call the one meant for squares, rectangles, or circles!

Inheritance is how classes can inherit the stuff from the public and protected part of their 'parent' class. Multiple Inheritance is when there are multiple layers going on.

To see an excellent example of inheritance, over multiple files, in my directory… /home/smalik2/src/cprog/c++

There is a multifile program using classes and inheritance and multiple inheritance.

break down and separate code into functions and illustrate the use of parameter passing

If you need to write a huge long program that does multiple things, that are similar to one another, this will be the capability to recognize the need for and be able to split the program apart into functions, so that code repetition is minimized and the code is more efficient.

If I start doing what I said in the definition. Which I believe I already do fairly solidly. In Project2 we continuously printed arrays, so I actually just made a function that would print an array given the array name and the length of the array.

I did a lot of this in Project 2.

I just did it. There's always room for improvement, but it is not desperately needed. There's not really a way to enhance checking to see if you can do it. I think the objective is stated nicely.

Namespaces are basically ways to create global variables, but with a sort of 'subscope' type of feeling. Basically, let's say you have the variable of 'health'. You have the health of your character and the health of a creature. Well, you can't use the same health for both. This is where namespaces come in - we can define your health under the namespace 'Character' or something, and the health of the creature under the namespace of 'Creature'. To call health, you need to specify the namespace::health now - ensuring that there is no mix up with the different healths.

The above paragraph is a pretty good example, but I'm going to put down some super basic code just to get the syntax on here.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>                                                                                                                                             
 
namespace Character
{
    int health=100;
    int combat;
    long long int gold;
}
 
namespace Creature
{
    int health=25;
    int combat;
    long long int gold = 7;
}
 
int main()
{
 
    printf("Do you wish to enter combat with 'Creature'?\n\n0 for no\n1 for yes\n");
    scanf("%u", &Character::combat);
 
    if (Character::combat == 0)
    {   
        printf("Have a nice glory-free day.\n");
        return 0;
    }   
 
    do  
    {   
        if(Character::combat == 1)
        {   
            Creature::combat=1;
        }   
        else
        {   
            Creature::combat=0;
        }   
        Creature::health=25;
        while((Character::combat==1) && (Creature::combat==1))
        {   
            Character::health = Character::health - 3;
            Creature::health = Creature::health - 7;
 
            if (Creature::health <= 0)
            {   
                Character::gold = Creature::gold + Character::gold;
                printf("You killed 'Creature'.\nYou received %llu gold.\nYou have %u health remaining", Creature::gold, Character::health);
                printf("\nYou now have %llu gold\n", Character::gold);
                break;
            }   
 
            if (Character::health <= 0)
            {   
                printf("You have died.\n");
                return 0;
            }   
        }   
 
        printf("Do you wish to fight another creature? 0 for no 1 for yes\n");
        scanf("%u", &Character::combat);
    }   
    while(Character::combat==1);
    printf("You have fled from combat.\n");
 
    return 0;
}

Alternatively (or additionally), if you want to demonstrate something on the command-line, you can do so as follows:

lab46:~/src/cprog/messingaround$ ./Namespaces 
Do you wish to enter combat with 'Creature'?

0 for no
1 for yes
1
You killed 'Creature'.
You received 7 gold.
You have 88 health remaining
You now have 7 gold
Do you wish to fight another creature? 0 for no 1 for yes
1
You killed 'Creature'.
You received 7 gold.
You have 76 health remaining
You now have 14 gold
Do you wish to fight another creature? 0 for no 1 for yes
1
You killed 'Creature'.
You received 7 gold.
You have 64 health remaining
You now have 21 gold
Do you wish to fight another creature? 0 for no 1 for yes
1
You killed 'Creature'.
You received 7 gold.
You have 52 health remaining
You now have 28 gold
Do you wish to fight another creature? 0 for no 1 for yes
1
You killed 'Creature'.
You received 7 gold.
You have 40 health remaining
You now have 35 gold
Do you wish to fight another creature? 0 for no 1 for yes
1
You killed 'Creature'.
You received 7 gold.
You have 28 health remaining
You now have 42 gold
Do you wish to fight another creature? 0 for no 1 for yes
1
You killed 'Creature'.
You received 7 gold.
You have 16 health remaining
You now have 49 gold
Do you wish to fight another creature? 0 for no 1 for yes
1
You killed 'Creature'.
You received 7 gold.
You have 4 health remaining
You now have 56 gold
Do you wish to fight another creature? 0 for no 1 for yes
1
You have died.
lab46:~/src/cprog/messingaround$ 

Functions are basically blocks of code that are run when called, and can be given inputs (parameters). You can pass parameters by value (just give it the identifier), Address (using the & symbol), and by Reference (by pointers, for passing an array).

Functions can return values of different types, whether they be int, float, etc.

Recursion is when you call a function within a function, with a conditional break.

#include<stdio.h>                                                                                                                  
#include<stdlib.h>
 
int sum(int, int, int, int);    //function prototype
 
int main()
{
    int a,b,c,d;
    a=b=c=d=0;
 
    printf("\nEnter four numbers\n");
    scanf("%d%d%d%d", &a, &b, &c, &d);
 
    printf("The sum of %d, %d, %d, and %d is: %d\n", a,b,c,d, sum(a, b, c, d));
 
    return (0);
 
}
 
 
int sum(int a, int b, int c, int d)
{
    int SUM;
 
    SUM = a + b + c + d;
 
    return (SUM);
}

Alternatively (or additionally), if you want to demonstrate something on the command-line, you can do so as follows:

#include <stdlib.h>                                                                                                                
#include <stdio.h>
 
int main(int argc, char **argv)
{
    unsigned char i;
 
    if(argc < 2)
    {   
        printf("%8s must be run with 1 or \
        more arguments, you only provided %hhu\n", *(argv+0),(argc-1));
        exit(1);
    }   
 
    printf("You ran this program with %hhu arguments, they are:\n", argc);
 
    for(i=0; i<argc; i++)
    {   
        printf("argv[%hhu]: %s\n", i, *(argv+i));
    }   
 
    return(0);
 
}

Templates are kind of like function overloading. Except, you do the SAME THING given different parameters.

The STL is basically a library just filled with tons of templates to do stuff.

#include <stdlib.h>                                                                                                                  
#include <stdio.h>
#include <cstdio>
#include <iostream>
 
using namespace std;
 
template <class T>  //The T will basically be replaced by whatever 
T larger (T x, T y) //data type is necessary
{
    if (x >= y)
    {   
        return x;
    }   
    else
    {   
        return y;
    }   
}
 
int main()
{
    int a = 1200, b = 12; 
    float c = 3.1415, d = 143.24;
    char e = 65, f = 'B';
 
    cout << larger(a,b) << endl;
    cout << larger(c,d) << endl;
    cout << larger(e,f) << endl;
 
    return 0;
}

lab46:~/src/cprog/messingaround$ ./Template 
1200
143.24
B

Classes are wonderful little things good for organizing larger scale programs.

Objects are the things in the class, functions or variables or constants or friends, etc. Constructor is what runs when the class is being set up for usage. Optionary. Destructor is what runs when the class is deleted. Optionary. Access Control refers to the Public Protect and Private deal going on.

Public - Anybody can access this part. Protected - Only children can access this part (children are other classes that inherit from this class). Private - Only this class can access these parts. Friends - Allow you to rip through Access control, and access private parts from outside the class they belong to.

“This” pointer - When you make a new class to call and define it as a pointer, you have to use → to refer to it instead of a period.

There's two class-based programs in

cd /home/smalik2/src/cprog/c++

Also, Project 3.

The compiler takes your source code and translates it to assembly language.

The preprocessor deals with taking care of stuff before the actual compiling begins.

Flags are the command line arguments to the compiler, such as -02.

Assembler takes the assembly code (step 1 of compiling) and converts it into true machine code.

The Linker takes care of making sure that stuff from other libraries and header files and stuff will work correctly and be there.

Multi-file programs are programs made over multiple files.

I'll compile a multi-file program here.

lab46:~/src/cprog/c++/today$ ls
main.cc  rectangle.cc  rectangle.h  shape.cc  shape.h  square.cc  square.h  triangle.cc  triangle.h
lab46:~/src/cprog/c++/today$ g++ -c *.cc
lab46:~/src/cprog/c++/today$ ls
main.cc  rectangle.cc  rectangle.o  shape.h  square.cc  square.o     triangle.h
main.o   rectangle.h   shape.cc     shape.o  square.h   triangle.cc  triangle.o
lab46:~/src/cprog/c++/today$ g++ -o Program *.o
lab46:~/src/cprog/c++/today$ ./Program 
1 for Rectangle
2 for Square
3 for Triangle
2
You chose square. Enter the width/length: 12

The perimeter is: 48
The area is: 144

Einen schönen Tag noch, Ruck.

lab46:~/src/cprog/c++/today$ 

Type Casting is basically converting some type of data into another type. Const is a keyword that means that the type can not be changed. Volatile is a keyword that means you can modify using some tricks.

We didn't really go into this in class, except for when we used arrays.

When we used malloc to create an array, we were type casting it so that the memory we gave to the array would behave properly - according to the data type that we wanted for the array.

float *Array;
Array = (float*)malloc(sizeof(float)*50);      //(float*) is a type cast.

A typedef basically let's you take something, and create a shortcut for it. This shortcut now represents what you originally typedef, and the two can be used interchangeably. An enum is a data type that consists of named values. A union is kind of like a struct, where it holds a bunch of different types of data. The trick is, you can only have one type of data in it at a given time. Assigning new data, overwrites the old data.

There's a typedef in the EoCE. There's an enum and union in my cprog folder.

Structures are basically The C version of classes. They are heterogeneous data types, and can hold multiple things. Functions and data types. They are really good and useful for organization oriented stuff.

On the EoCE there is a lot of strcuture stuff on 0x6 and 0x7.

justify the use of various programming constructs within code solutions

This objective means being able to build a solution for a problem using some sensible approach. On top of that, you outta be able to come up with very sound reasons for your approach. (Why did I use classes to do this? For example).

I can judge how well I organize my code, and whether or not my methods make sense/ are good.

I normally take a very good approach in how I organize and construct my solutions to problems, so I figure I do a pretty decent job of it.

• How did you do? I think I did well.
• Is there room for improvement? Of course there is!
• Could the measurement process be enhanced to be more effective? I don't know - perhaps using an outside source. If somebody else can tell why I took an approach that's even better.
• Do you think this enhancement would be efficient to employ? If people agreed to help me.
• Could the course objective be altered to be more applicable? How would you alter it? Not particularly, I wouldn't alter it.