c++ overview
TRANSCRIPT
![Page 1: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/1.jpg)
DATA STRUCTURES & ALGORITHMS
C++ WARM-UP
- PREM RANJAN
![Page 2: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/2.jpg)
OUTLINE
• History and overview
• Basic features
• Parameter passing
• Classes
• Inheritance and virtual
• Header file
• IO
• Memory Management
• Big three: destructor, copy constructor, and assignment operator
• Const
• Template
![Page 3: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/3.jpg)
HISTORY OF C++
• 1972: C language developed at Bell Labs
• Dennis Ritchie wrote C for Unix OS
• Needed C for work with Unix
• late 70s: C becomes popular for OS development by many vendors
• Many variants of the language developed
• ANSI standard C in 1987-89
![Page 4: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/4.jpg)
HISTORY OF C++ (CONTINUED)
• early 80s: Bjarne Stroustrup adds OO features to C creating C++
• 90s: continued evolution of the language and its applications
• preferred language for OS and low level programming
• popular language for application development
• low level control and high level power
![Page 5: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/5.jpg)
CONCEPTUALLY WHAT IS C++
• Alternatives:
• is it C, with lots more options and features?
• is it an OO programming language with C as its core?
• is it a development environment?
• On most systems it is a development environment, language, and library, used for both procedural and object oriented programming, that can be customized and extended as desired
![Page 6: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/6.jpg)
VERSIONS OF C++
• ANSI C++
• Microsoft C++ (MS Visual C++ 6.0)
• Other vendors: Borland, Symantec, Turbo, …
• Many older versions (almost annual) including different version of C too
• Many vendor specific versions
• Many platform specific versions
• For this class: Unix / Linux based versions
• g++
![Page 7: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/7.jpg)
CHARACTERISTICS OF C++ AS A COMPUTER LANGUAGE
• Procedural
• Object Oriented
• Extensible
• ...
![Page 8: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/8.jpg)
OTHER OO LANGUAGES
• Smalltalk
• pure OO language developed at PARC
• Java
• built on C/C++
• objects and data types
• Eifel and others
![Page 9: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/9.jpg)
WHAT YOU CAN DO WITH C++
• Apps (standalone, Web apps, components)
• Active desktop (Dynamic HTML, incl Web)
• Create graphical apps
• Data access (e-mail, files, ODBC)
• Integrate components w/ other languages
![Page 10: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/10.jpg)
DISADVANTAGES OF C++
• Tends to be one of the less portable languages
• Complicated?
• 40 operators, intricate precedence, pointers, etc.
• can control everything
• many exceptions and special cases
• tremendous libraries both standard, vendor specific, and available for purchase, but all are intricate
• Aspects above can result in high maintenance costs
![Page 11: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/11.jpg)
ADVANTAGES OF C++
• Available on most machines
• Can get good performance
• Can get small size
• Can manage memory effectively
• Can control everything
• Good supply of programmers
• Suitable for almost any type of program (from systems programs to applications)
![Page 12: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/12.jpg)
OUTLINE
• History and overview
• Basic features
• Parameter passing
• Classes
• Inheritance and virtual
• Header file
• IO
• Memory Management
• Big three: destructore, copy constructor, and assignment operator
• Const
• Template
![Page 13: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/13.jpg)
PRIMITIVE TYPES
• bool true or false (only C++)
• char 8/16-bit
• short 16-bit signed integer
• int 32-bit signed integer
• unsigned 32-bit unsigned integer
• long 32 / 64-bit signed integer
• float 32-bit floating point
• double 64-bit floating point
![Page 14: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/14.jpg)
OPERATORS AND PRECEDENCE
• [ ] . • to access arrays elements / to access object methods and fields
• expr++ expr-- ++expr --expr !
• new (type)expr
• * / %
• + -
• << >> (integers only)
• < > >= <=
• == !=
• &
![Page 15: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/15.jpg)
OPERATORS AND PRECEDENCE
• ^
• |
• && (booleans only)
• || (booleans only)
• ?:
• = += -= *= ….
• C++ allows operator overloading
![Page 16: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/16.jpg)
PRECEDENCE EXAMPLE
• What is: 5 + 21 / 4 % 3
• = 5 + (21 / 4) % 3
• = 5 + ( 5 % 3)
• = 5 + 2
• = 7
![Page 17: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/17.jpg)
EXPLICIT CASTING
• (type) expression
• Possible among all integer and float types
• Possible among some class references
• E.g. int i = (int) ( (double)5 / (double)3 )
![Page 18: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/18.jpg)
IMPLICIT CASTING
• Applied automatically provided there is no loss of precision
• float double
• int double
• Example
• int iresult, i=3;
• double dresult, d=3.2;
• dresult = i/d => implicit casting dresult=0.9375
• iresult = i/d => error! Why? Loss in precision, needs explicit casting
![Page 19: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/19.jpg)
CONTROL FLOW
if (boolean)
statement;
else if(boolean)
statement2;
else
statement3;
Booleans only, not integers!• if (i > 0) correct
• if (i = 2) correct / incorrect ?
![Page 20: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/20.jpg)
SWITCH / CASE
• switch (controlVar)
{
case 'a' :
statement-1
break;
case 'b' :
statement-2
break;
default :
statement-3
break;
}
• Do not forget the break command to avoid surprise result!
![Page 21: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/21.jpg)
LOOPS
while(<boolean>)
statement;
do
statement;
while(<boolean>)
for(init-expr; <boolean>; incr-expr)
statement;
![Page 22: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/22.jpg)
SOME CONVENTIONS FOR VARIABLE NAMES
• Use letters and numbers
• Do not use special characters including spaces, dots, underlines, pound signs, etc.
• The first letter will be lower case
• Use variable names that are meaningful (except for occasional counters that we might call i, j, x, etc.)
• You can concatenate words, and capitalize each after the first, e.g., bankBal, thisAcctNum, totAmt
• If you abbreviate, be consistent. For example do not use both bankBal and totalBalance as variable names.
![Page 23: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/23.jpg)
SOME CONVENTIONS FOR STRUCT AND CLASS NAMES
• In creating names of structs and classes, apply the same rules as for variable names, except the first character will be upper case
• Example:
• an object's name: myCar
• the struct or class name: Car
• Another Example: aPerson and Person
![Page 24: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/24.jpg)
OUTLINE
• History and overview
• Basic features
• Parameter passing
• Classes
• Inheritance and virtual
• Header file
• IO
• Memory Management
• Big three: destructore, copy constructor, and assignment operator
• Const
• Template
![Page 25: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/25.jpg)
PASSING PARAMETERS
• C++ allows for three different ways of passing parameters:
• Pass “by value”
• E.g. foo (int n)
• Appropriate for small objects (usually primitive types) that should not be altered by the function call
• Pass “by constant reference”
• E.g. foo(const T& myT)
• Appropriate for large objects that should not be altered by the function call
• Pass “by reference”
• E.g. foo(bool & errFlag)
• Appropriate for small objects that can be altered by the function call
• Array types are always passed “by reference”
![Page 26: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/26.jpg)
PASSING BY VALUE
void square(int i)
{
i = i*i;
}
int main()
{
int i = 5;
square(i);
cout << i << endl;
}
![Page 27: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/27.jpg)
PASSING BY REFERENCE
void square(int& i)
{
i = i*i;
}
int main()
{
int i = 5;
square(i);
cout << i << endl;
}
![Page 28: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/28.jpg)
PASSING BY CONSTANT REFERENCE
void square(const int& i)
{
i = i*i;
}
int main()
{
int i = 5;
square(i);
cout << i << endl;
}
Wont work, why?
![Page 29: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/29.jpg)
PASSING BY CONSTANT REFERENCE
int square(const int& i)
{
return i*i;
}
int main()
{
int i = 5;
cout << square(i) << endl;
}
Will it his work?
![Page 30: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/30.jpg)
WHAT IS A REFERENCE?
• An alias – another name for an object.
int x = 5;
int &y = x; // y is a reference to x
y = 10;
• What happened to x?
• What happened to y? – y is x.
![Page 31: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/31.jpg)
WHY ARE THEY USEFUL?
• When passing argument of large size (class type), can save space
• Sometimes need to change a value of an argument
• Can be used to return more than one value (pass multiple parameters by reference)
![Page 32: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/32.jpg)
HOW ARE REFERENCES DIFFERENT FROM POINTERS?
Reference Pointer
int a = 10;
int b = 20;
int &c = a;
c = b;
What is the value of a?
int a = 10;
int b = 20;
int *c = &a;
c = &b;
![Page 33: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/33.jpg)
OUTLINE
• History and overview
• Basic features
• Parameter passing
• Classes
• Inheritance and virtual
• Header file
• IO
• Memory Management
• Big three: destructore, copy constructor, and assignment operator
• Const
• Template
![Page 34: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/34.jpg)
CLASSES
• Provide a mechanism for defining classes of objects.
• We can define the class of all computers to have certain characteristics.
• An instance of a computer is your home PC.
• Classes contain member variables and member functions.
![Page 35: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/35.jpg)
CLASSES IN C++:WHY CREATE CLASSES / OBJECTS?
• Keeps all related info (i.e., data) together
• Refer to all the related info by one name
• Protect the information
• Hide methods that use or change the info
• Keep methods together with their related info
![Page 36: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/36.jpg)
EXAMPLE OF BENEFITS OF CREATING AN OBJECT
• Keeps all related info (i.e., data) together
Person thisPerson;
Person thisPerson = new Person ("Bill", "Clinton", 52);
• Refer to all the related info by one name
thisPerson
• Protect the information
lastName = "Dole"; //normally data members are private, and member functions are public
![Page 37: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/37.jpg)
CLASSES AND OBJECTS
Mammals
Humans Tigers
Hank Peggy Tony
class
classclass
inherits inherits
instance-ofinstance-of
![Page 38: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/38.jpg)
EXAMPLE OF A SIMPLE CLASS
class Change
{
private:
int quarters;
int dimes;
public:
int getQuarters() {return quarters;}
int getDimes() {return dimes;}
void setQuarters(int aQuarters) {quarters = aQuarters;}
…...
void printChange()
{cout << "\nQuarters: " << quarters
<< " Dimes: " << dimes << endl;
}
};
![Page 39: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/39.jpg)
MORE CLASS EXAMPLE
class human
{
// this data is private to instances of the class
int height;
char name[];
int weight;
public:
void setHeight(int heightValue);
int getHeight();
};
![Page 40: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/40.jpg)
FUNCTION DEFINITIONS
void human::setHeight(int heightValue)
{
if (heightValue > 0)
height = heightValue;
else
height = 0;
}
int human::getHeight()
{
return(height);
}
![Page 41: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/41.jpg)
EXAMPLE
// first we define the variables.
int height = 72;
int result = 0;
human hank;
//set our human’s height
hank.setHeight(height);
//get his height
result = hank.getHeight();
cout << “Hank is = “ << result <<
“inches tall” << endl;
Hank is 72 inches tall
Output
![Page 42: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/42.jpg)
INSTANTIATING AN OBJECT
• The class definition does not create any objects
• Instantiating and constructing are equivalent words for building a new object based on the model (i.e., template) of the class
• Instantiating is done just like declaring a variable of a built in data type
• Instantiating is done by a constructor (sometimes called a constructor method)
• If the "class provider" does not provide a constructor, then the C++ compiler provides a default one automatically
• The default constructor does not provide values to the data members (i.e. the instance variables)
![Page 43: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/43.jpg)
INSTANTIATING AN OBJECT (MORE)
• When the object is instantiated, memory is allocated
• Example of instantiation (implicit call of constructor)
Car myCar;
Elephant oneElephant, twoElephant;
• No initialization takes place
• Each object has its own memory allocation
• oneElephant and twoElephant are separate objects in different locations in memory
• Each is addressed individually by name or location
• Each data member is addressed individually using the object name and the data member name, for example:
oneElephant.age
twoElephant.name
![Page 44: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/44.jpg)
REFERENCING AN OBJECT
• Each object has a name (or a location) which is assigned when the object is instantiated
• private data members are accessible only within the class
• since most data members are private, that means that these data items are accessed generally by means of member functions
• myElephant.age = 72; //won't work, assuming is declared as private
• myElephant.setAge(72); // will work
![Page 45: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/45.jpg)
OUTLINE
• History and overview
• Basic features
• Parameter passing
• Classes
• Inheritance and virtual
• Header file
• IO
• Memory Management
• Big three: destructore, copy constructor, and assignment operator
• Const
• Template
![Page 46: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/46.jpg)
INHERITANCE
• The power of object-oriented languages
• Enables reuse of fields/methods
• All parent fields included in child instantiation
• Protected and public fields and methods directly accessible to child
• Parent methods may be overridden
• New fields and methods may be added to the child
• Multiple inheritance
![Page 47: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/47.jpg)
INHERITANCE (CONT’D)
class classname: public parentname {
private:
….;
public:
….;
//access to parent methods through
// parentname::methodname …
}
![Page 48: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/48.jpg)
OUTLINE
• History and overview
• Basic features
• Parameter passing
• Classes
• Inheritance and virtual
• Header file
• IO
• Memory Management
• Big three: destructore, copy constructor, and assignment operator
• Const
• Template
![Page 49: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/49.jpg)
HEADER FILE
• For complex classes, the member functions are declared in a header file and the member functions are implemented in a separate file.
• This allows people to look at the class definitions, and their member functions separately
• The header file needs to be included in your program when you use the classes defined in the head file
![Page 50: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/50.jpg)
#include “Segment.H”
#include <iostream>
# INCLUDE
Insert header file at this point.
Use library header.
![Page 51: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/51.jpg)
HEADER GUARDS
#ifndef __SEGMENT_HEADER__
#define __SEGMENT_HEADER__
// contents of Segment.H
//...
#endif
• To ensure it is safe to include a file more than once.
![Page 52: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/52.jpg)
HEADER GUARDS
#ifndef __SEGMENT_HEADER__
#define __SEGMENT_HEADER__
// contents of segment.H
//...
#endif
• To ensure it is safe to include a file more than once.
If this variable is
not defined…Define it.
End of guarded area.
![Page 53: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/53.jpg)
OUTLINE
• History and overview
• Basic features
• Parameter passing
• Classes
• Inheritance and virtual
• Header file
• IO
• Memory Management
• Big three: destructore, copy constructor, and assignment operator
• Const
• Template
![Page 54: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/54.jpg)
OUTPUT
#include<iostream>
Tell compiler that we are doing I/O
cout
Object to which we can send data.
<<
operator for sending data.
endl `\n’ `\t’
Special symbols that we can send.
![Page 55: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/55.jpg)
FORMATTING OUTPUT
ios::left left justify the output
ios::right right justify the output
ios::scientific use scientific notation for numbers
ios::hex print numbers in hexadecimal base
ios::dec print numbers in decimal base
ios::uppercase print all characters in upper case
cout.setf(long flag) cout.unsetf(long flag)
Set different formatting
parameters for next output.
Disable these formatting
parameters.
![Page 56: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/56.jpg)
EXAMPLE
#include<iostream.h>
main()
{
cout.width(10); //sets width to 10
cout << “hello” << endl;
cout.setf(ios::left);
cout << “hello” << endl;
cout << 16 << endl;
cout.setf(ios::hex, ios::basefield);
cout << 16 << endl;
}
hello
hello
16
10
Output
![Page 57: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/57.jpg)
INPUT
#include <iostream.h>
Tell the linker we are doing basic I/O
cin
The input object. It retrieves input from the keyboard
>>
The extractor operator.
![Page 58: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/58.jpg)
EXAMPLE
#include <iostream.h>
main ()
{
int userInput;
cout << “Enter number:”;
cin >> userInput;
cout << “You entered ” <<
userInput << endl;
}
Enter number:12345
You entered 12345
Output
![Page 59: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/59.jpg)
I/O FROM A FILE
• I/O from a file is done in a similar way.
#include <iostream.h>
#include <fstream.h>
main()
{
int inputNumber;
ofstream myOutputFile(“outfile”);
ifstream myInputFile(“infile”);
myOutputFile << “text to file.” << endl;
myInputFile >> inputNumber;
myOutputFile.close();
myInputFile.close();
}
![Page 60: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/60.jpg)
#include <string>
#include <fstream>
#include <iostream>
#include <iomanip>
using namespace std;
int main(int argc, char *argv[])
{
// Check input
if(argc<2)
{
cout<<"Usage: "<<argv[0]<<" <filename>"<<endl;
return 0;
}
// Try to read from file
cout<<"Reading tokens from file '"<<argv[1]<<"':"<<endl;
ifstream in(argv[1]);
if(!in)
cout<<" - Could not read from file '"<<argv[1]<<"'."<<endl;
else
{
string token;
cout.setf(ios::right);
for(unsigned i=1; in>>token; i++)
cout<<setw(4)<<i<<": "<<token<<endl;
}
in.close();
cout<<endl;
// Allow user to enter a token
string text;
cout<<"Enter some text: ";
getline(cin, text);
// Append new tokens to file
ofstream out(argv[1], ios::app);
if(out)
out<<endl<<text<<endl;
else
cout<<"- Could not write to file '"<<argv[1]<<"'"<<endl;
out.close();
return 0;
}
This program reads a file
name given by the user and
the read token by token from
the file. The tokens are
printed to the standard
output.
The second half of the
algorithm reads a token from
a standard input and appends
it to the file that was given.
![Page 61: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/61.jpg)
OUTLINE
• History and overview
• Basic features
• Parameter passing
• Classes
• Inheritance and virtual
• Header file
• IO
• Memory Management
• Big three: destructore, copy constructor, and assignment operator
• Const
• Template
![Page 62: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/62.jpg)
WHAT IS A POINTER?
int x = 10;
int *p;
p = &x;
p gets the address of x in memory.
p
x10
![Page 63: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/63.jpg)
WHAT IS A POINTER?
int x = 10;
int *p;
p = &x;
*p = 20;
*p is the value at the address p.
p
x20
![Page 64: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/64.jpg)
WHAT IS A POINTER?
int x = 10;
int *p;
p = &x;
*p = 20;
Declares a pointer
to an integer
& is address operator
gets address of x
* dereference operator
gets value at p
![Page 65: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/65.jpg)
A POINTER EXAMPLE
int main(){
int i, j;
int *pi, *pj;
i = 5;
j = i;
pi = &i;
pj = pi;
*pj = 4;
cout << i << “ “;
cout << j << “ “;
cout << *pi << “ “;
cout << *pj << endl;
return 0;
}
> 4, 5, 4, 4
![Page 66: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/66.jpg)
ALLOCATING MEMORY USING NEW
Point *p = new Point(5, 5);
• Point is a class already defined
• new can be thought of a function with slightly strange syntax
• new allocates space to hold the object.
• new calls the object’s constructor.
• new returns a pointer to that object.
![Page 67: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/67.jpg)
MEMORY ALLOCATION EXAMPLES
• new returns a pointer to the dynamically created object.
#include “Cow.h”
#include <iostream>
using namespace std;
int main(){
int *i = new int(12);
Cow *c = new Cow;
...
delete i;
delete c;
return 0;
}
![Page 68: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/68.jpg)
PROBLEMS
• Dangling pointers
• Pointers to memory that has already been deallocated
• segmentation fault (core dump)... or worse....
• Memory leak
• Loosing pointers to dynamically allocated memory
• Substantial problem in many commercial products
• See Windows 98
• C++ HAS NO GARBAGE COLLECTION!
![Page 69: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/69.jpg)
DANGLING POINTER EXAMPLES
int main(){
int *myNum = new int(12);
int *myOtherNum = myNum;
delete myNum;
cout << *myOtherNum << endl;
return 0;
}
int* badFunction(){
int num = 10;
return #
}
int* stillBad(int n){
n += 12;
return &n;
}
int main(){
int num = 12;
int *myNum = badFunction();
int *myOtherNum = stillBad(num);
cout << *myNum << “, “;
cout << *myOtherNum << endl;
return 0;
}
![Page 70: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/70.jpg)
MEMORY LEAK EXAMPLES
int main(){
int *myNum = new int(12);
myNum = new int(10);
// Oops...
delete myNum;
return 0;
}
int evilFunction(){
int *i = new int(9);
return *i;
}
int main(){
int num = evilFunction();
// I’m loosing my memory!!
return 0;
}
![Page 71: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/71.jpg)
DEALLOCATING MEMORY USING DELETE
// allocate memory
Point *p = new Point(5, 5);
...
// free the memory
delete p;
For every call to new, there must be
exactly one call to delete.
![Page 72: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/72.jpg)
USING NEW WITH ARRAYS
int x = 10;
int* nums1 = new int[10]; // ok
int* nums2 = new int[x]; // ok
• Initializes an array of 10 integers on the heap.
• C++ equivalent of C
int* nums = (int*)malloc(x * sizeof(int));
![Page 73: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/73.jpg)
USING NEW WITH MULTIDIMENSIONAL ARRAYS
int x = 3, y = 4;
int* nums3 = new int[x][4][5];// ok
int* nums4 = new int[x][y][5];// BAD!
• Initializes a multidimensional array
• Only the first dimension can be a variable. The rest must be constants.
• Use single dimension arrays to fake multidimensional ones
![Page 74: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/74.jpg)
USING DELETE ON ARRAYS
// allocate memory
int* nums1 = new int[10];
int* nums3 = new int[x][4][5];
...
// free the memory
delete[] nums1;
delete[] nums3;
• Have to use delete[].
![Page 75: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/75.jpg)
OUTLINE
• History and overview
• Basic features
• Parameter passing
• Classes
• Inheritance and virtual
• Header file
• IO
• Memory Management
• Big three: destructore, copy constructor, and assignment operator
• Const
• Template
![Page 76: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/76.jpg)
CLASS DESTRUCTORS
• If a class dynamically allocates memory, we need a way to deallocate it when it’s destroyed.
• Distructors called upon distruction of an object
class MyClass{
public:
MyClass(){
// Constructor
}
~MyClass(){
// Destructor
}
...
};
![Page 77: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/77.jpg)
DESTRUCTORS
• delete calls the object’s destructor.
• delete frees space occupied by the object.
• A destructor cleans up after the object.
• Releases resources such as memory.
![Page 78: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/78.jpg)
DESTRUCTORS – AN EXAMPLE
class Segment
{
public:
Segment();
virtual ~Segment();
private:
Point *m_p0, *m_p1;
};
![Page 79: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/79.jpg)
DESTRUCTORS – AN EXAMPLE
Segment::Segment()
{
m_p0 = new Point(0, 0);
m_p1 = new Point(1, 1);
}
Segment::~Segment()
{
delete m_p0;
delete m_p1;
}
![Page 80: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/80.jpg)
COPY CONSTRUCTOR AND ASSIGNMENT OPERATOR
• Copy Constructor:
class Rooster{
public:
...
Rooster(const Rooster &rhs){
// Do your deep copy
}
...
};
...
// Usage
Rooster r(12);
Rooster s(r);
• Assignment Operator:
class Rooster{
public:
...
Rooster&
operator=(const Rooster &rhs){
// Copy stuff
}
...
};
...
// Usage
Rooster r(12), s(10);
r = s;
![Page 81: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/81.jpg)
CANONICAL FORM
• All classes should have each of the following:
• Default constructor
• Copy constructor
• Assignment operator
• Destructor
// Canonical Cow
class Cow{
public:
Cow(){...}
Cow(const Cow &rhs){...}
Cow& operator=(const Cow &c)
{...}
~Cow(){...}
...
};
![Page 82: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/82.jpg)
OUTLINE
• History and overview
• Basic features
• Parameter passing
• Classes
• Inheritance and virtual
• Header file
• IO
• Memory Management
• Big three: destructore, copy constructor, and assignment operator
• Const
• Template
![Page 83: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/83.jpg)
INTRODUCING: CONST
void Math::printSquare(const int& i)
{
i = i*i;
cout << i << endl;
}
int main()
{
int i = 5;
Math::printSquare(i);
Math::printCube(i);
}
Won’t compile.
![Page 84: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/84.jpg)
HOW DOES CONST WORK HERE?
void Math::printSquares(const int& j, int& k)
{
k = k*k; // Does this compile?
cout << j*j << “, “ << k << endl;
}
int main()
{
int i = 5;
Math::printSquares(i, i);
}
![Page 85: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/85.jpg)
RETURNING CONST REFERENCES IS OK
class Point
{
point:
const double& getX() const;
const double& getY() const;
void move(double dx, double dy);
private:
double m_x, m_y;
}
const double& Point::getX()
const
{
return m_x;
}
Constant function, also called accessor
Return a reference to a
constant double
![Page 86: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/86.jpg)
NAMESPACES
• Namespaces are kind of like packages in Java
• Reduces naming conflicts
• Most standards C++ routines and classes and under the stdnamespace
![Page 87: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/87.jpg)
USING NAMESPACE
#include <iostream>
...
std::string question =
“How do I prevent RSI?”;
std::cout << question << std::endl;
using namespace std;
string answer = “Type less.”;
cout << answer << endl;
But, not in header files!
![Page 88: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/88.jpg)
OUTLINE
• History and overview
• Basic features
• Parameter passing
• Classes
• Inheritance and virtual
• Header file
• IO
• Memory Management
• Big three: destructor, copy constructor, and assignment operator
• Const
• Template
![Page 89: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/89.jpg)
TEMPLATE
What exactly are templates for, and why learn them?
• Limited Generic Programming (polymorphism)Some functions have the same semantic meaning for some (if not all) data
types. For instance, a function print() should display a sensible
representation of anything passed in. Ideally, it shouldn’t need to be
rewritten for each possible type.
• Less repetitive codeCode that only differs in the data type it handles does not have to be
rewritten for each and every data type you want to handle. It’s easier to
read and maintain since one piece of code is used for everything
![Page 90: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/90.jpg)
EXAMPLE: A SWAP FUNCTION
Naive method – write an overloaded function for each type
void swap(int &a, int &b) {
int c = a;
a = b;
b = c;
}
void swap(T &a, T &b) {
T c = a;
a = b;
b = c;
}
Swap for integers Swap for an arbitrary type T
template <typename T>
void swap(T &a, T &b) {
T c = a;
a = b;
b = c;
}
This function can be used with any
type that supports assignment and can
be passed in as a non-const reference.
Problem: Oftentimes, it is nice to be able to swap the values of two variables. This function’s behavior is similar for all data types. Templated functions let you do that – in most cases without any syntax changes.
Template method – write one templated function
![Page 91: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/91.jpg)
TEMPLATE SYNTAX: SWAP DISSECTED
template <typename T>
void swap(T &a, T &b) {
T c = a;
a = b;
b = c;
}
The template<…> line states that everything in the following declaration or definition is under the subject of the template. (In this case, the definition is the function swap)
In here goes a list of “placeholders variables.” In almost all cases, they will be specified with either the typename or class keywords. These two keywords are equivalent.
“Placeholder variables” have one value within each template declaration. Think of them as being replaced by whatever type you specify the template to be.
![Page 92: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/92.jpg)
TEMPLATE SYNTAX: USING IT
template <typename T>
void swap(T &a, T &b) {
T c = a;
a = b;
b = c;
}
Example:double d1 = 4.5, d2 = 6.7;
swap(d1, d2);
Syntax
![Page 93: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/93.jpg)
CLASS TEMPLATES: EXAMPLE
Example: A templated, dynamic, 2 dimensional array (Matrix)*
#ifndef MATRIX_H
#define MATRIX_H
template <typename T>
class Matrix {
public:
Matrix(int rows, int cols);
Matrix(const Matrix &other);
virtual ~Matrix();
Matrix& operator=(const Matrix &rhs);
T* operator[](int i);
int getRows() const;
int getCols() const;
protected:
void copy(const Matrix &other);
private:
Matrix();
int m_rows;
int m_cols;
T *m_linArray;
};
#endif /* MATRIX_H */File: Matrix.h
Notice the only addition to the class definition is the line:template <typename T>
Within the the definition block, the placeholder has can be used as a data type. When the template is specialized, it takes on the value of the specialization.
![Page 94: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/94.jpg)
template <typename T>
T* Matrix<T>::operator[](int i) {
return m_linArray + (i*m_cols);
}
template <typename T>
void
Matrix<T>::copy(const Matrix &other) {
m_rows = other.m_rows;
m_cols = other.m_cols;
int size = m_rows * m_cols;
m_linArray = new T[size];
for( int i=0; i < size; i++ ) {
m_linArray[i] =
other.m_linArray[i];
}
}
template <typename T>
int Matrix<T>::getRows() const {
return m_rows;
}
template <typename T>
int Matrix<T>::getCols() const {
return m_cols;
}
CLASS TEMPLATES: EXAMPLE CONT’D
#include "Matrix.h"
template <typename T>
Matrix<T>::Matrix()
{}
template <typename T>
Matrix<T>::Matrix(int rows, int cols) {
m_rows = rows;
m_cols = cols;
m_linArray = new T[m_rows * m_cols];
}
template <typename T>
Matrix<T>::Matrix(const Matrix &other) {
copy(other);
}
template <typename T>
Matrix<T>::~Matrix() {
delete[] m_linArray;
}
template <typename T>
Matrix<T>&
Matrix<T>::operator=(const Matrix &other) {
if( this != &other ) {
delete[] m_linArray;
copy(other);
}
return *this;
} File: Matrix.cc
![Page 95: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/95.jpg)
template <typename T>
Matrix<T>&
Matrix<T>::operator=(const Matrix &other) {
if( this != &other ) {
this->~Matrix();
copy(other);
}
return *this;
}
CLASS TEMPLATES: MEMBER FUNCTIONS DISSECTED
Again, a templated class name by itself has no meaning (eg. Matrix by itself means nothing). It only gets meaning through specialization, explicit or implicit. Thus, when referring to an instance of a templated class (a specific specialization), the class name must be explicitly specialized.
Here, the template has been implicitly specialized by its context. It is within the specialization regionof the class scope. Thus it does not need the template arguments. For a class definition, the specialization region is the class block.
specialization region of
Matrix<T>::Notice that the specialization region does not include the return type. Thus the return type needs explicit specialization
This may be obvious, but remember that though constructors and destructors have the same name as a the class template, they are functions and do not need to be specialized.
![Page 96: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/96.jpg)
CLASS TEMPLATES: USAGE
• Templated classes must be explicitly specialized. Thus, to create a 2 dimensional Matrix of doubles using the last example, the syntax would be:
Matrix<double> m(3,3);
Syntax
![Page 97: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/97.jpg)
STL
• Allows you to easily store anything without writing a container yourself
• Will give you the most hideous compile errors ever if you use them incorrectly.
![Page 98: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/98.jpg)
STL EXAMPLE
using namespace std;
typedef list<int> intlist;
typedef intlist::iterator intlistIter;
intlist v;
v.push_back(4);
intlistIter a;
for(a = v.begin(); a != v.end(); ++a)
{
int c = (*a);
}
![Page 99: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/99.jpg)
• Now compile and run a simple c++ program
![Page 100: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/100.jpg)
COMPILATION MODEL
• Preprocessor
• Resolves all preprocessor directives
• #include, #define macros, #ifdef, etc.
• Compiler
• Converts text into object files
• May have unresolved interobject references
• Linker
• Resolves all interobject references (or gives you a linker error)
• Creates the binary executable
• Loader
• Loads the program into RAM and runs the main() function
![Page 101: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/101.jpg)
COMPILATION
PreprocessorInlines #includes etc.
CompilerTranslates to machine code
Associates calls with functions
LinkerAssociates functions with definitions
Object files
Executable
External Libraries, libc.so, libcs123.so
![Page 102: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/102.jpg)
HELLOWORLD.CPP
#include <iostream> // For cout
using namespace std;
int main(){
cout << "Hello World!" << endl;
return 0;
}
![Page 103: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/103.jpg)
COMPILING WITH G++
ix$ ls
hello.cpp
ix$ ls
hello.cpp
ix$ g++ hello.cpp
ix$ ls
a.out* hello.cpp
ix$ g++ -c hello.cpp
ix$ ls
a.out* hello.cpp hello.o
ix$ g++ -o hello hello.cpp
ix$ ./hello
Hello World!
![Page 104: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/104.jpg)
MAKEFILE
> make
![Page 105: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/105.jpg)
SIMPLE MAKEFILE
All: hello
hello: hello.o
g++ -o hello hello.o
hello.o: hello.cpp
g++ -c hello.cpp
![Page 106: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/106.jpg)
ix$ ls
hello.cpp makefile
ix$ make
g++ -c hello.cpp
g++ -o hello hello.o
ix$ ls
hello* hello.cpp hello.o makefile
ix$ ./hello
Hello World!
![Page 107: C++ overview](https://reader030.vdocuments.us/reader030/viewer/2022032421/55a61d121a28ab6c4c8b45e5/html5/thumbnails/107.jpg)