Transcript Programming in C++
Programming in C++
•
Teacher:
• Lisa Brouwers – PhD student – [email protected]
•
Litterature:
• Jesse James, “Teach yourself C++ in 21 days”
General information
•
Lessons
: Monday, Wednesday and Thursday 9 - 12 and 13 - 16 in #606 • •
Exercises
: Tuesday and Friday
Examination
: • 8 small assignments • 1 large assignment (co-assignment with the course in agent-programming)
Lesson 1, topics
• Algorithm • Pseudo-code • Why C++ ?
• Object-Oriented programming • First program (Hello World) • Types • Variables & Constants • Expressions & Statements
Algorithm
“A series of steps that systematically outline how to accomplish a goal.” Find a suitable method for solving the problem The description of how to solve the problem is called an algorithm An algorithm must: • solve the problem • be non-ambiguous • - if the problem has a final goal, the algorithm must terminate after a
finite
number of steps
More on algorithms
• There are three (omitting the goto…) ways a computer can work its way through a set of instructions. It can: • Sequence – execute the instructions in
sequence
; • Selection – use some test to decide which of two sets of instructions to perform; • Iteration – repeat some set of instructions over and over. • For handling complex problems: • Divide into sub-problems • • Solve the sub-problems independently or (if still too complex): – divide the sub-problems further • continue until all sub-problems can be solved easily
Pseudo-code
• “A high-level abstraction of code, used to outline the
general
steps in an algorithm without having to write actual code”
Example (algorithm in pseudo-code)
An algorithm in
pseudo-code
, describing how the sum of 1 + 2 + 3 + … +
n
, can be calculated.
n
is known and is an integer > 0: 1. Set ‘
sum’
to 0 and the counter
k
to 1.
2. Repeat the following until
k
is larger than
n
: 2.1 Add
‘sum’
and k and store the result in
‘sum’
2.2 Increase
k
by 1 3. The result looked for is now in
‘sum’
Example continued
Expressed as part of a C++ program the code looks like: cin >> n; sum = 0; for (int k = 1; k<=n; k++) sum += k; cout << sum;
• • •
Why Program in C++?
1. C++ allows expression of abstract ideas
– C++ is a third generation language that allows a programmer to express their ideas at a high level as compared to assembly languages.
2. C++ still allows a programmer to keep low-level control
– Even though C++ is a 3G language, it allows a programmer to get down into the low-level workings and tune as necessary. C++ allows programmers strict control over memory management.
3. C++ has national standards (ANSI)
– Code written in C++ that conforms to the national standards can be easily integrated with pre-existing code. Programmers can reuse certain common libraries, so certain common functions do not need to be written more than once, and these functions behave the same anywhere they are used.
Why Program in C++ (2)
• •
4. C++ is reusable and object-oriented
– C++ is an object-oriented language. This makes programming conceptually easier (once the object paradigm has been learned) and allows easy reuse of code, or parts of code through inheritance.
5. C++ is widely used and taught
– C++ is a very widely used programming language. Because of this, there are many tools available for C++ programming, and there is a broad base of programmers contributing to the C++ "community".
Object-oriented (OO) programming
• A type of programming in which programmers define not only the data type of a data structure, but also the types of operations (functions) that can be applied to the data structure. In this way, the data structure becomes an
object
that includes both data and functions. In addition, programmers can create
relationships
between one object and another. For example, objects can
inherit
characteristics from other objects. • One of the principal advantages of OO programming techniques over procedural programming techniques is that they enable programmers to create modules that do not need to be changed when a new type of object is added. A programmer can simply create a new object that inherits many of its features from existing objects. This makes object oriented programs easier to modify.
What is an object?
• An object-oriented program is made up of objects. • An
object
has an internal state (i.e. variables that are local to the object) and operations to modify that state. • For example, Björn’s car is an object. It has an internal state consisting of 'amount of fuel', 'make of car', 'number of miles driven' and 'colour' and it responds to the operations 'drive
n
miles', 'how many miles have you driven?' and 'repaint with colour
c
'. • Where relevant, objects know how to display themselves on the screen and how to load and save themselves.
What is an Instance
• Every object is an
instance
of (belongs to) a
class
. • In simple terms a class is just a template for the object. It contains details of all the behaviour of an object along with what state information the object has (i.e. it has the code and data structure definitions). • 'Car' is an example of a
class
. It describes what it is like to be a car but it isn't actually a car itself. • To make a 'real' car you have to
instantiate
the class, and then you get an object such as Björn’s car which is a blue Mitsubishi or Anna’s car which is a red Saab.
"Hello, World"
#include
suffixes: .c, .cc, .cxx, .cpp, or .c++;
Compile , but do not link: Compile, link and place output in file
hello
: The compiler issues
warnings
´: g++
-c
hello.cc
g++ -o file
hello
hello.cc
g++ -Wall -o file
hello
hello.cc
Int main( )
• Main is a special function in C++, because it is called automatically when you execute a program.
• It returns an int (to the operating system) , therefore you should add the line
return 0;
as last line in the main function.
Input (cin)
#include
and store the value 3 in i1, 'e' in c1, 3.4 in f1 and "yes" in s1.
Output (cout)
#include
cout can output constant values, variables, expressions or manipulators
Simple data-types
The built-in scalar C++ types include:
Type
int long float double char enum
Size *
16 32 32 64 8 16
Range *
-32768 to 32,767 -128 to 127 -32768 to 32,767
Comments
Most common integer type -2,147,483,648 to 2,147,483,647 Used when
int
is not large enough 3.4 x 10 -38 to 3.4 x 10 38 1.7 x 10 -308 to 1.7 x 10 308 Real Numbers with 7 digit prec.
Real Numbers with 15 digit prec. For ASCII-char’s and small integers Enumerated types * As found in Borland C++ 5.0
Declaring variables
• • • • • • Names for variables, constants, functions, classes and user-defined types are called
identifiers
. All identifiers must be
declared
before they can be used in a program. Identifiers must start with a letter or an underscore, '_', but digits can be included elsewhere. C++ is a
case sensitive
language meaning that the identifiers 'abc', ABC', and 'aBc' are all different.
Whitespace
cannot be included in identifiers. A variable declaration consists of a type name, an identifier name, and possibly an equal sign (=) followed by a value -
to initialise the variable.
Declaring variables (2)
Valid declarations include:
int value1, value2 = 3; double sum; char initial;
// value2 is
initialised
to 3 Note the semicolon at the end of each declaration.
Declaring constants
C++ programs can include specific integer, real, character, and string values. Such values are called
constants
. Constants must be
initialised
and can not change value during runtime. Numeric constants (integer and real constants) appear simply as values. Character constants consist of single characters surrounded by single quotes. String constants are some sequence of zero or more characters surrounded by double quotes. Examples of constants include:
2, 341, 4.55, -45, -56.78, 'a', 'Z', '2', "a", "Z", "Hello there”
Note that
'a'
is a character constant while
"a"
is a string constant. A variable of type char could hold 'a' but not "a". Also,
'2'
is a character while the digit
2
is an integer. Often, constants are declared in programs as
named constants
. The best way to make such a declaration is by using the word
const
followed by the type of the constant, the name (identifier) of the constant, an equal sign, and its value:
const int MAX_ITEMS = 23; const char INITIAL = 'J'; const double PI = 3.1417;
Assignment-operator ( = )
Name of variable(identifier) = expression the value of the expression on the right hand side is first evaluated. The value is then
assigned
to the variable on the left hand side.
The old value of the variable is overwritten.
The expression on the RHS must be of the same type, or be automatically transformed into, as the variable.
Statements & expressions
• •
compound-statement
{
statement-list ?
}
• • •
statement-list statement statement-list statement
• • • • • •
statement declaration-statement expression-statement function-statement flow-control-statement compound-statement
Statements & expressions (2)
• A
declaration-statement
is any declaration of a variable. Variables can be declared along with an initialisation. In C++ this can include a value computed in earlier statements in that block. • An
expression-statement
is an expression, including assignments. • A
function-statement
is a function call. • A
flow-control statement
is a conditional, switch or loop statement.
Arithmetic Operators
• Addition + • Subtraction • Multiplication * • Division / (when int’s are divided the rest is omitted, 8 / 3 = = 2) • Modulus % (the
rest
in a division, 8 % 3 = = 2)
Shorthand operators
• Int a = 5; • a = a + 5; instead….
• a+=5; //plus-equals • works with all arithmetic operators.
Postfix Increment and Decrement
Int b = 1; b+=1; // b is increased by 1 instead you can write:
b++; // postfix
increment, fetch the value and then increase it by 1 likewise you can decrease the value (by one): b--; The value of the variable can also be in-/decreased
first
(before fetching the value).
Int a = 0, b = 5; a = b++; a is assigned the value of a (5), after this the value of a is increased a=++b; the value of b is first increased (to 7) thereafter the value is assigned to a.
Program Structure [selection]
if
(
some test condition )
{
block 1
}
else
{
block2
}
// the program continues The 'else' part is optional.
The brackets are not required in either part if only one statement is to be executed, but you are advised to always include them to avoid certain errors, hard to understand.
When executed, this statement first evaluates the test condition. If
TRUE
is returned, the system executes the first block and then moves on to the code after the second set of brackets . If
FALSE
is returned by the test, the system executes the code inside the 2nd block and then continues with the rest of the program. If there is no 'else' clause, it continues with the rest of the program.
The test condition can involve both
relational
and
logical
operators.
Relational operators (true or false)
Equals Not equals Gr than = = != > Gr than or Eq Less than >= < Less than or Eq <= --------------------------------- Logical operators AND OR NOT !
&& | |
Declarations vs. Definitions
A
declaration
by itself does not include the setting aside or allocation of memory for the identifier being declared. It is only a statement describing what may later come into existence in the computer's memory. A statement that sets aside memory is called a
definition
. Int SomeFunction(int, int); // declaration - no body int SomeFunction(int first, int second) //definition, tells what the function does { first += second; return first; }
The type enum
Used for things you describe in words rather than in numbers, the days of a week for instance.
When defining a variable of the type enum you specify the possible values the variable may take: int day; enum weekDay {Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday}; cout <<“Enter a week-day (0 - 6)\n”; cin>>day; if (day = = Saturday || day == Sunday) cout<<“That is in the week-end.\n”; else cout<< “This is in the week.\n”;
Lesson 2, topics
• Functions – parameters – return values • Define a new class • Create instances of the class • member-data, -functions • Constructors • Looping (WHILE and FOR)
Functions
• When a program calls a function the execution switches to the function and then resumes at the line after the call to the function.
• Functions can return something or nothing.
• If they return nothing, they are said to return
void
• Returning functions can return any type (int, char, string etc) • You can send data to a function (arguments) • The functions are first declared ( a declaration = a prototype) and then defined • But it is possible to declare the function already in the declaration.
Declaring a function
• Write the prototype (declaration) in a file that is included in your program • Write the prototype direct in the program where the function is used • returntype FunctionName(type para1, …);
Defining a function
Int SomeFunction(int a, int b) {
do something….
return (a*b); } the function may take many parameters of different types you can use Local variables within the function, and the values of those local variables can be returned from the function.
Global variables
• Variables defined outside all functions (even main) have global scope.
• Local variables hide global ones.
• Global variables can be reached from functions by ::
Parameters are local variables
• The formal parameters are assigned the values of the actual parameters (with which the function is called).
• Changes are made on the copies only • Parameters are passed by value • correct value can be returned instead
Overloading functions
• You may define several functions with the same name, if they are different enough.
• They must differ in at least: – number of parameters or/and – type of parameters • Return-type is
not
different enough
classes
• Own data-type – encapsulates data (member-data) – and related functions (member-functions)
class
Cat{ //declaration of class Cat int itsAge; void Meow(); };
More on classes
The member-functions of a class must be defined as well: void Cat::Meow(){cout<<“Meooow\n”}; //definition To call a member you must first create an instance (object) of the class: Cat Frisky; Frisky.itsAge = 10; you reach the inner of an object by using the dot-operator Frisky is an instance or an Object of the type (class) Cat.
Even more on classes
• Private / Public – private data-members are only accessible to member-functions in the same class – Keep data private • Accessor-functions – used to manipulate private data • Isolate the interface (declaration of the class) in a header-file • Define the classmethods in a .cpp program (or .cc or..) • Constructors • Destructors
Looping!
• Iteration • the WHILE statement • while (condition) • • FOR-loops
for
(int i = 0; cond.; i++)
References in C++
• For example: int ix; /* ix is "real" variable */ int &rx = ix; /* rx is "alias" for ix */ ix = 1; /* also rx == 1 */ rx = 2; /* also ix == 2 */ • References can be used as function arguments and return values. This allows to pass parameters as reference or to return a ``handle'' to a calculated variable or object.