BICT Solutions |
C++ Programming Language Quick Summary
C++ is a programming language of many different
dialects, similar to the way that each spoken language has many different
dialects. In C++, dialects are not because the speakers live in the North or
South. Instead, it is because there are many different compilers that support
slightly different features. There are several common compilers: in particular,
#include <iostream>
using namespace std;
int main() { cout<<"HEY, you, I'm alive! Oh, and Hello World!\n"; cin.get(); } Let's look at the elements of the program. The #include
is a "preprocessor" directive that tells the compiler to put code from the
header called iostream into our program before actually creating the executable.
By including header files, you an gain access to many different functions. For
example, the cout function requires iostream. Following the include is the
statement, "using namespace std;". This line tells the compiler to use a group
of functions that are part of the standard library (std). By including this line
at the top of a file, you allow the program to use functions such as cout. The
semicolon is part of the syntax of C and C++. It tells the compiler that you're
at the end of a command. You will see later that the semicolon is used to end
most commands in C++.
#include <iostream>
using namespace std;
int main() { cout<<"HEY, you, I'm alive! Oh, and Hello World!\n"; cin.get();
return 1; } The final brace closes off the function. You should try
compiling this program and running it. You can cut and paste the code into a
file, save it as a .cpp (or whatever extension your compiler requires) file. If
you are using a command-line compiler, such as Borland C++ 5.5, you should read
the compiler instructions for information on how to compile. Otherwise compiling
and running should be as simple as clicking a button with your mouse.
int x; int a, b, c, d; char letter; float the_float; While you can have multiple variables of the same type,
you cannot have multiple variables with the same name. Moreover, you cannot have
variables and functions with the same name.
#include <iostream>
using namespace std;
int main() { int thisisanumber;
cout<<"Please enter a number: "; cin>> thisisanumber; cin.ignore(); cout<<"You entered: "<< thisisanumber <<"\n"; cin.get(); } Let's break apart this program and examine it line by
line. The keyword int declares thisisanumber to be an integer. The function cin>>
reads a value into thisisanumber; the user must press enter before the number is
read by the program. cin.ignore() is another function that reads and discards a
character. Remember that when you type intput into a program, it takes the enter
key too. We don't need this, so we throw it away. Keep in mind that the variable
was declared an integer; if the user attempts to type in a decimal number, it
will be truncated (that is, the decimal component of the number will be
ignored). Try typing in a sequence of characters or a decimal number when you
run the example program; the response will vary from input to input, but in no
case is it particularly pretty. Notice that when printing out a variable
quotation marks are not used. Were there quotation marks, the output would be
"You Entered: thisisanumber." The lack of quotation marks informs the compiler
that there is a variable, and therefore that the program should check the value
of the variable in order to replace the variable name with the variable when
executing the output function. Do not be confused by the inclusion of two
separate insertion operators on one line. Including multiple insertion operators
on one line is perfectly acceptable and all of the output will go to the same
place. In fact, you must separate string literals (strings enclosed in
quotation marks) and variables by giving each its own insertion operators (<<).
Trying to put two variables together with only one << will give you an error
message, do not try it. Do not forget to end functions and declarations with a
semicolon. If you forget the semicolon, the compiler will give you an error
message when you attempt to compile the program.
a = 4 * 6; // (Note use of comments and of semicolon) a is 24 a = a + 5; // a equals the original value of a with five added to it a == 5 // Does NOT assign five to a. Rather, it checks to see if a equals 5. The other form of equal, ==, is not a way to assign a
value to a variable. Rather, it checks to see if the variables are equal. It is
useful in other areas of C++; for example, you will often use == in such
constructions as conditional statements and loops. You can probably guess how <
and > function. They are greater than and less than operators.
a < 5 // Checks to see if a is less than five a > 5 // Checks to see if a is greater than five a == 5 // Checks to see if a equals five, for good measure Without a conditional
statement such as the if statement, programs would run almost the exact same way
every time. If statements allow the flow of the program to be changed, and so
they allow algorithms and more interesting code.
> greater than 5 > 4 is TRUE < less than 4 < 5 is TRUE >= greater than or equal 4 >= 4 is TRUE <= less than or equal 3 <= 4 is TRUE == equal to 5 == 5 is TRUE != not equal to 5 != 4 is TRUE It is highly probable that you have seen these before,
probably with slightly different symbols. They should not present any hindrance
to understanding. Now that you understand TRUE and FALSE in computer terminology
as well as the comparison operators, let us look at the actual structure of if
statements.
if ( TRUE ) Execute the next statement To have more than one statement execute after an if
statement that evaluates to true, use braces, like we did with the body of a
function. Anything inside braces is called a compound statement, or a block.
if ( TRUE ) { Execute all statements inside the braces } There is also the else statement. The code after it
(whether a single line or code between brackets) is executed if the if statement
is FALSE.
if ( TRUE ) { // Execute these statements if TRUE } else { // Execute these statements if FALSE } One use for else is if there are two conditional
statements that may both evaluate to true, yet you wish only one of the two to
have the code block following it to be executed. You can use an else if after
the if statement; that way, if the first statement is true, the else if will be
ignored, but if the if statement is false, it will then check the condition for
the else if statement. If the if statement was true the else statement will not
be checked. It is possible to use numerous else if statements.
#include <iostream>
using namespace std;
int main() // Most important part of the program! { int age; // Need a variable...
cout<<"Please input your age: "; // Asks for age cin>> age; // The input is put in age cin.ignore(); // Throw away enter if ( age < 100 ) { // If the age is less than 100 cout<<"You are pretty young!\n"; // Just to show you it works... } else if ( age == 100 ) { // I use else just to show an example cout<<"You are old\n"; // Just to show you it works... } else { cout<<"You are really old\n"; // Executed if no other statement is } cin.get(); } Boolean operators allow you to create more complex
conditional statements. For example, if you wish to check if a variable is both
greater than five and less than ten, you could use the boolean AND to ensure
both var > 5 and var < 10 are true. In the following discussion of boolean
operators, I will capitalize the boolean operators in order to distinguish them
from normal english. The actual C++ operators of equivalent function will be
described further into the tutorial - the C++ symbols are not: OR, AND, NOT,
although they are of equivalent function.
A. !( 1 || 0 ) ANSWER: 0 B. !( 1 || 1 && 0 ) ANSWER: 0 (AND is evaluated before OR) C. !( ( 1 || 0 ) && 0 ) ANSWER: 1 (Parenthesis are useful) Loops are used to repeat a block of code. Being able to have your program repeatedly execute a block of code is one of the most basic but useful tasks in programming -- many programs or websites that produce extremely complex output (such as a message board) are really only executing a single task many times. (They may be executing a small number of tasks, but in principle, to produce a list of messages only requires repeating the operation of reading in some data and displaying it.) Now, think about what this means: a loop lets you write a very simple statement to produce a significantly greater result simply by repetition.
for ( variable initialization; condition; variable update ) { Code to execute while the condition is true } The variable initialization allows you to either declare
a variable and give it a value or give a value to an already existing variable.
Second, the condition tells the program that while the conditional expression is
true the loop should continue to repeat itself. The variable update section is
the easiest way for a for loop to handle changing of the variable. It is
possible to do things like x++, x = x + 10, or even x = random ( 5 ), and if you
really wanted to, you could call other functions that do nothing to the variable
but still have a useful effect on the code. Notice that a semicolon separates
each of these sections, that is important. Also note that every single one of
the sections may be empty, though the semicolons still have to be there. If the
condition is empty, it is evaluated as true and the loop will repeat until
something else stops it.
#include <iostream>
using namespace std; // So the program can see cout and endl
int main() { // The loop goes while x < 10, and x increases by one every loop for ( int x = 0; x < 10; x++ ) { // Keep in mind that the loop condition checks // the conditional statement before it loops again. // consequently, when x equals 10 the loop breaks. // x is updated before the condition is checked. cout<< x <<endl; } cin.get(); } This program is a very simple example of a for loop. x is
set to zero, while x is less than 10 it calls cout<< x <<endl; and it adds 1 to
x until the condition is met. Keep in mind also that the variable is incremented
after the code in the loop is run for the first time.
#include <iostream>
using namespace std; // So we can see cout and endl
int main() { int x = 0; // Don't forget to declare variables
while ( x < 10 ) { // While x is less than 10 cout<< x <<endl; x++; // Update x so the condition can be met eventually } cin.get(); } This was another simple example, but it is longer than
the above FOR loop. The easiest way to think of the loop is that when it reaches
the brace at the end it jumps back up to the beginning of the loop, which checks
the condition again and decides whether to repeat the block another time, or
stop and move to the next statement after the block.
do { } while ( condition ); Notice that the condition is tested at the end of the
block instead of the beginning, so the block will be executed at least once. If
the condition is true, we jump back to the beginning of the block and execute it
again. A do..while loop is basically a reversed while loop. A while loop says
"Loop while the condition is true, and execute this block of code", a do..while
loop says "Execute this block of code, and loop while the condition is true".
#include <iostream>
using namespace std;
int main() { int x;
x = 0; do { // "Hello, world!" is printed at least one time // even though the condition is false cout<<"Hello, world!\n"; } while ( x != 0 ); cin.get(); } Keep in mind that you must include a trailing semi-colon
after the while in the above example. A common error is to forget that a
do..while loop must be terminated with a semicolon (the other loops should not
be terminated with a semicolon, adding to the confusion). Notice that this loop
will execute once, because it automatically executes before checking the
condition. Functions that a programmer
writes will generally require a prototype. Just like a blueprint, the prototype
tells the compiler what the function will return, what the function will be
called, as well as what arguments the function can be passed. When I say that
the function returns a value, I mean that the function can be used in the same
manner as a variable would be. For example, a variable can be set equal to a
function that returns a value between zero and four.
#include <cstdlib> // Include rand()
using namespace std; // Make rand() visible
int a = rand(); // rand is a standard function that all compilers have Do not think that 'a' will change at random, it will be
set to the value returned when the function is called, but it will not change
again.
return-type function_name ( arg_type arg1, ..., arg_type argN ); arg_type just means the type for each argument -- for
instance, an int, a float, or a char. It's exactly the same thing as what you
would put if you were declaring a variable.
int mult ( int x, int y ); This prototype specifies that the function mult will
accept two arguments, both integers, and that it will return an integer. Do not
forget the trailing semi-colon. Without it, the compiler will probably think
that you are trying to write the actual definition of the function.
#include <iostream>
using namespace std;
int mult ( int x, int y );
int main() { int x; int y;
cout<<"Please input two numbers to be multiplied: "; cin>> x >> y; cin.ignore(); cout<<"The product of your two numbers is "<< mult ( x, y ) <<"\n"; cin.get(); }
int mult ( int x, int y ) { return x * y; } This program begins with the only necessary include file
and a directive to make the std namespace visible. Everything in the standard
headers is inside of the std namespace and not visible to our programs unless we
make them so. Next is the prototype of the function. Notice that it has the
final semi-colon! The main function returns an integer, which you should always
have to conform to the standard. You should not have trouble understanding the
input and output functions. It is fine to use cin to input to variables as the
program does. But when typing in the numbers, be sure to separate them by a
space so that cin can tell them apart and put them in the right variables.
cout<<"The product of your two numbers is "<< x * y <<"\n"; The mult function is actually defined below main. Due to
its prototype being above main, the compiler still recognizes it as being
defined, and so the compiler will not give an error about mult being undefined.
As long as the prototype is present, a function can be used even if there is no
definition. However, the code cannot be run without a definition even though it
will compile. The prototype and definition can be combined into one also. If
mult were defined before it is used, we could do away with the prototype because
the definition can act as a prototype as well.
Switch case statements are a substitute for long if statements that compare a variable to several "integral" values ("integral" values are simply values that can be expressed as an integer, such as the value of a char). The basic format for using switch case is outlined below. The value of the variable given into switch is compared to the value following each of the cases, and when one value matches the value of the variable, the computer continues executing the program from that point.
switch ( <variable> ) { case this-value: Code to execute if <variable> == this-value break; case that-value: Code to execute if <variable> == that-value break; ... default: Code to execute if <variable> does not equal the value following any of the cases break; } The condition of a switch statement is a value. The case says that if it has the value of whatever is after that case then do whatever follows the colon. The break is used to break out of the case statements. Break is a keyword that breaks out of the code block, usually surrounded by braces, which it is in. In this case, break prevents the program from falling through and executing the code in all the other case statements. An important thing to note about the switch statement is that the case values may only be constant integral expressions. Sadly, it isn't legal to use case like this:
int a = 10; int b = 10; int c = 20;
switch ( a ) { case b: // Code break; case c: // Code break; default: // Code break; } The default case is optional, but it is wise to include
it as it handles any unexpected cases. Switch statements serves as a simple way
to write long if statements when the requirements are met. Often it can be used
to process input from a user.
#include <iostream>
using namespace std;
void playgame(); void loadgame(); void playmultiplayer();
int main() { int input;
cout<<"1. Play game\n"; cout<<"2. Load game\n"; cout<<"3. Play multiplayer\n"; cout<<"4. Exit\n"; cout<<"Selection: "; cin>> input; switch ( input ) { case 1: // Note the colon, not a semicolon playgame(); break; case 2: // Note the colon, not a semicolon loadgame(); break; case 3: // Note the colon, not a semicolon playmultiplayer(); break; case 4: // Note the colon, not a semicolon cout<<"Thank you for playing!\n"; break; default: // Note the colon, not a semicolon cout<<"Error, bad input, quitting\n"; break; } cin.get(); } This program will compile, but cannot be run until the
undefined functions are given bodies, but it serves as a model (albeit simple)
for processing input. If you do not understand this then try mentally putting in
if statements for the case statements. Default simply skips out of the switch
case construction and allows the program to terminate naturally. If you do not
like that, then you can make a loop around the whole thing to have it wait for
valid input. You could easily make a few small functions if you wish to test the
code. What are pointers? Why should you care?Pointers are aptly named: they "point" to locations in
memory. Think of a row of safety deposit boxes of various sizes at a local bank.
Each safety deposit box will have a number associated with it so that the teller
can quickly look it up. These numbers are like the memory addresses of
variables. A pointer in the world of safety deposit box would simply be anything
that stored the number of another safety deposit box. Perhaps you have a rich
uncle who stored valuables in his safety deposit box, but decided to put the
real location in another, smaller, safety deposit box that only stored a card
with the number of the large box with the real jewelery. The safety deposit box
with the card would be storing the location of another box; it would be
equivalent to a pointer. In the computer, pointers are just variables that store
memory addresses, usually the addresses of other variables. Pointer SyntaxPointers require a bit of new syntax because when you
have a pointer, you need the ability to request both the memory location it
stores and the value stored at that memory location. Moreover, since pointers
are somewhat special, you need to tell the compiler when you declare your
pointer variable that the variable is a pointer, and tell the compiler what type
of memory it points to.
<variable_type> *<name>; For example, you could declare a pointer that stores the address of an integer with the following syntax:
int *points_to_integer; Notice the use of the *. This is the key to declaring a pointer; if you add it directly before the variable name, it will declare the variable to be a pointer. Minor gotcha: if you declare multiple pointers on the same line, you must precede each of them with an asterisk:
// one pointer, one regular int int *pointer1, nonpointer1;
// two pointers int *pointer1, *pointer2; As I mentioned, there are two ways to use the pointer to access information: it is possible to have it give the actual address to another variable. To do so, simply use the name of the pointer without the *. However, to access the actual memory location, use the *. The technical name for this doing this is dereferencing the pointer; in essence, you're taking the reference to some memory address and following it, to retrieve the actual value. It can be tricky to keep track of when you should add the asterisk. Remember that the pointer's natural use is to store a memory address; so when you use the pointer:
call_to_function_expecting_memory_address(pointer); then it evaluates to the address. You have to add something extra, the asterisk, in order to retrieve the value stored at the address. You'll probably do that an awful lot. Nevertheless, the pointer itself is supposed to store an address, so when you use the bare pointer, you get that address back. Pointing to Something: Retrieving an AddressIn order to have a pointer actually point to another
variable it is necessary to have the memory address of that variable also. To
get the memory address of a variable (its location in memory), put the & sign in
front of the variable name. This makes it give its address. This is called the
address-of operator, because it returns the memory address. Conveniently, both
ampersand and address-of start with a; that's a useful way to remember that you
use & to get the address of a variable.
#include <iostream>
using namespace std;
int main() { int x; // A normal integer int *p; // A pointer to an integer
p = &x; // Read it, "assign the address of x to p" cin>> x; // Put a value in x, we could also use *p here cin.ignore(); cout<< *p <<"\n"; // Note the use of the * to get the value cin.get(); } The cout outputs the value stored in x. Why is that?
Well, let's look at the code. The integer is called x. A pointer to an integer
is then defined as p. Then it stores the memory location of x in pointer by
using the address-of operator (&) to get the address of the variable. Using the
ampersand is a bit like looking at the label on the safety deposit box to see
its number rather than looking inside the box, to get what it stores. The user
then inputs a number that is stored in the variable x; remember, this is the
same location that is pointed to by p.
int *ptr = new int; It initializes ptr to point to a memory address of size
int (because variables have different sizes, number of bytes, this is
necessary). The memory that is pointed to becomes unavailable to other programs.
This means that the careful coder should free this memory at the end of its
usage.
delete ptr; After deleting a pointer, it is a good idea to reset it
to point to 0. When 0 is assigned to a pointer, the pointer becomes a null
pointer, in other words, it points to nothing. By doing this, when you do
something foolish with the pointer (it happens a lot, even with experienced
programmers), you find out immediately instead of later, when you have done
considerable damage. Taking Stock of PointersPointers may feel like a very confusing topic at first but I think anyone can come to appreciate and understand them. If you didn't feel like you absorbed everything about them, just take a few deep breaths and re-read the lesson. You shouldn't feel like you've fully grasped every nuance of when and why you need to use pointers, though you should have some idea of some of their basic uses.
Lesson 7: Structures (Printable
Version)
[3]
struct Tag { Members }; Where Tag is the name of the entire type of structure and Members are the variables within the struct. To actually create a single structure the syntax is
struct Tag name_of_single_structure; To access a variable of the structure it goes
name_of_single_structure.name_of_variable; For example:
struct example { int x; }; struct example an_example; //Treating it like a normal variable type an_example.x = 33; //How to access it's members Here is an example program:
struct database { int id_number; int age; float salary; };
int main() { database employee; //There is now an employee variable that has modifiable // variables inside it. employee.age = 22; employee.id_number = 1; employee.salary = 12000.21; } The struct database declares that database has three variables in it, age, id_number, and salary. You can use database like a variable type like int. You can create an employee with the database type as I did above. Then, to modify it you call everything with the 'employee.' in front of it. You can also return structures from functions by defining their return type as a structure type. For instance:
database fn(); I will talk only a little bit about unions as well.
Unions are like structures except that all the variables share the same memory.
When a union is declared the compiler allocates enough memory for the largest
data-type in the union. Its like a giant storage chest where you can store one
large item, or a small item, but never the both at the same time.
#include <iostream>
using namespace std;
struct xampl { int x; };
int main
|