Object-Oriented Programming in C++

Transcription

1 Object-Oriented Programming in C++ Pre-Lecture 2: Prof Niels Walet Room 7.07, Schuster Building January 30, 2015

2 Prelecture 2 Outline In this pre-lecture we will cover more of C++ s enhanced functionality, specifically Overloading functions Replacing pointers with references Dynamically allocating (and freeing) memory Using the file stream

3 Overloading functions Requirement: a function to perform the same task with more than one data type Solution: in C, write a separate function for each type Problem: each function must be called something different C++ removes this barrier; functions can be overloaded

4 Overloading functions Example: old way 1 #include <iostream > 2 using namespace std; 3 double max_double( double a, double b) 4 { 5 if(a>b) return a; else return b; 6 } 7 int max_int(int a, int b) 8 { 9 if(a>b) return a; else return b; 10 } 11 int main() 12 { 13 int ai(1),bi(2); 14 double ad(4.),bd(3.); 15 cout <<max_int(ai,bi)<<endl <<max_double(ad,bd)<<endl; 16 return 0; 17 } Listing 1 : PL2/max1.cpp (Compact layout for size!)

5 Overloading functions Example: C++ way 1 #include <iostream > 2 using namespace std; 3 double max( double a, double b) 4 { 5 if(a>b) return a; else return b; 6 } 7 int max(int a, int b) 8 { 9 if(a>b) return a; else return b; 10 } 11 int main() 12 { 13 int ai(1),bi(2); 14 double ad(4.),bd(3.); 15 cout <<max(ai,bi)<<endl <<max(ad,bd)<<endl; 16 return 0; 17 } Listing 2 : PL2/max2.cpp Compiler checks argument type to decide which version to use Further simplifications can be made using templates, covered in the penultimate lecture.

6 Pointers and References The above functions contain two parameters (a and b) Arguments were passed by value: local copies were made inside functions Sometimes it is better to pass by reference (i.e. pass starting address of data so function has direct access) Two main reasons for passing by reference: You want to pass a complex argument (object) to the function (and don t want to spend all the time on copying!) You want to modify the variables being passed inside the function In C, this is done using pointers. Recall, a pointer holds the location (address) of a variable, e.g. float *x; // x is declared as a pointer to a float float y{2}; // y is an ordinary float, set to 2 x=&y; // x now points to y (so x contains address of y) cout <<*x<<endl; // de- reference x ( prints out 2)

7 Pointers and References Passing an array An array is really a pointer, set up to point to each element, as can be seen from the code 1 #include <iostream > 2 using namespace std; 3 void printarray(const int N, int *array) { 4 // show that array[i] is equivalent to *(array+i) 5 for(int i=0;i<n;i++) 6 cout <<array[i]<<" "<<*(array+i)<<endl; 7 return; 8 } 9 int main() { 10 const int N(3); 11 int array[n]; 12 for(int i(0);i<n;i++) array[i]=i; 13 printarray(n,array); // array equivalent to &array[0] 14 return 0; 15 } Listing 3 : PL2/array.cpp which outputs Very much the C position

8 Pointers and References Using a reference When wanting to pass a single object 1 by reference, can be easier to use a reference New C++ feature; simplifies syntax Example: compare using pointer and reference 1 Will become clearer later, for now read object as single int, double etc.

9 Pointers and References Example using a reference (C-style) by value: 1 #include <iostream > 2 using namespace std; 3 4 void doublemyvalue( double a) { 5 a*=2; 6 } 7 8 int main() { 9 double x(4.); 10 cout <<x<<endl; 11 doublemyvalue(x); 12 cout <<x<<endl; 13 return 0; 14 } Listing 4 : PL2/byvalue.cpp which outputs 4 4

10 Pointers and References Example using a reference (C-style) by reference: 1 #include <iostream > 2 using namespace std; 3 4 void doublemyvalue( double *a) { 5 (*a)*=2; 6 } 7 8 int main() { 9 double x(4.); 10 cout <<x<<endl; 11 doublemyvalue(&x); 12 cout <<x<<endl; 13 return 0; 14 } Listing 5 : PL2/byreference.cpp which outputs 4 8

11 Pointers and References Example using a reference (C-style) Pointers can sometimes get confusing The function was defined to take a pointer (to a double) as its sole argument void doublemyvalue( double *a) { Since the pointer stores an address of a double, the address of x (in main()) had to be double x(4.); The pointer then had to be de-referenced in the function (*a)*=2;

12 Pointers and References Example using a reference (C++-style) by reference: 1 #include <iostream > 2 using namespace std; 3 4 void doublemyvalue( double& a) { 5 a*=2; 6 } 7 8 int main() { 9 double x(4.); 10 cout <<x<<endl; 11 doublemyvalue(x); 12 cout <<x<<endl; 13 return 0; 14 } Listing 6 : PL2/byreference2.cpp which outputs 4 8

13 Pointers and References Example using a reference (C++-style) To pass by reference, just modify the argument in the function by inserting an ampersand, void doublemyvalue( double& a) { No pointers (and de-referencing) required anymore Also safer - the compiler can check that something valid will be referenced

14 Pointers and References Example using a reference Can also declare references within code (but must be assigned) 4 int main() { 5 int a(4); 6 int &b(a); // b refers to a (so b will change if a changes) 7 cout <<a<<" "<<b<<endl; 8 a++; 9 cout <<a<<" "<<b<<endl; 10 return 0; produces Listing 7 : selection of PL2/byreference3.cpp Note that references must refer to something! int &c; // invalid as c not initialized (must refer to a valid object) References must also be of the same type as the objects they refer to int a;float &d(a); // invalid as a is of type int

15 Dynamic Memory Allocation Often we do not know how much memory we require in advance Common example: data of unknown size to be read in from file Solution: use dynamic memory allocation In C this is done using the malloc function

16 Dynamic Memory Allocation: C example The following code fragment outlines the creation and destruction of memory to be used for storing an array of doubles /* First create a pointer that we will use to point to our data */ double * mydata;... /* Allocate memory for N doubles - mydata will now be an array */ mydata=malloc(n* sizeof( double));... /* Code that reads in data goes here - assume file will contain N doubles */... /* Do what we want to do with the data */... /* Now we are finished with mydata, free memory up */ free( mydata); Note that in C, the malloc function takes the number of bytes as its argument

17 Dynamic Memory Allocation: C++ example In C++, dynamic memory allocation is handled using two new functions: new and delete To allocate memory, create a pointer (as before) and then use the new command double * mydata; // declare mydata as a pointer to a double mydata = new double[n]; // mydata now points to new array of N doubles Advantage: no need to work out the size of the array in bytes. This can be done more concisely (declare variables when we need them!) double *mydata = new double[n];

18 Dynamic Memory Allocation In C++, dynamic memory allocation is handled using two new functions: new and delete To allocate memory, create a pointer (as before) and then use the new command double * mydata; // declare mydata as a pointer to a double mydata = new double[n]; // mydata now points to new array of N doubles Advantage: no need to work out the size of the array in bytes. This can be done more concisely (declare variables when we need them!) double *mydata = new double[n];

19 Dynamic Memory Allocation General syntax for allocating memory for a single variable // Allocate memory for variable of type DataType1 // Memory is accessed with pointer myscalar DataType1 * myscalar = new DataType1; And for an array // Allocate memory for array of type DataType2 // Memory is accessed with pointer myarray DataType2 * myarray = new DataType2[N]; Memory is freed up as follows delete myscalar; // single variable delete[] myarray; // array Always free up memory when you have finished with it! (Known as garbage collection) Dynamically allocated memory goes on the heap - could run out during program if not freed (memory leaks) - vital for mission critical applications

20 File Streams We already met the standard I/O stream commands, cin and cout To access these, we needed #include<iostream>= The devices connected to these streams are unambiguous (keyboard and screen) and these streams are opened and closed for you C++ also provides streams to connect to files But we now need to define the device (file) connected to our stream, the stream type and we need to open and close them ourselves

21 File Streams Opening and closing To use file streams we need to add #include<fstream> We then need to define our type of file stream ifstream myinputfile; // a file stream for reading only ofstream myoutputfile; // a file stream for writing only fstream myfile; // a file stream for reading or writing To open our file we can use myfile.open("data1"); // open file called data1 Or we can define and open our file stream at once fstream myfile("data1"); // Open and attach data1 to myfile To close our file myfile.close();

22 File Streams Reading and writing Syntax is the same as for the standard I/O streams E.g. to read a double from a file double mydata; myfile >>mydata; // extract a double from the file stream myfile To write out an int to a file int mycode (32762); myfile <<mycode; // insert mycode into file stream myfile

23 File Streams Useful checks It is useful to check if our file opened succesfully fstream myfile("data1"); // Check file opened successfully if(!myfile.good()) { // Print error message and exit cerr <<"Error: file could not be opened"<<endl; return(1); } Note: cerr is the standard error stream (usually the screen) Can also check the data is read or written successfully myfile >>x; if(myfile.fail()) { cerr <<"Error: could not read data from file"<<endl; return(1); }

24 File Streams Useful checks If such rogue data (e.g. character) detected can skip with commands myfile.clear(); // take stream out of fail state myfile. ignore(); // ignore unwanted character Might need to apply above more than once We can also check for the end-of-file (or not!), e.g. while(!myfile.eof()) { // Read in some more data... } // Must have reached the end so close file myfile.close();