csis 123a lecture 6 strings & dynamic memory. introduction to the string class must include...

CSIS 123A Lecture 6

Strings & Dynamic Memory

Introduction To The string Class

• Must include <string>– Part of the std library

• You can declare an instance like any other class– string str;

• Notice string is lower case• = operator is overloaded so you can set

strings– str = “Hello World”;

• Can also be initialized as it is declared– string str = “Hello World”;– Or std::string str = “Hello World”;

Has Friend functions

• You can use cin and cout with strings– << and >> are friends of the class

#include <iostream>#include <string>using namespace std;int main(){string s; cin >> s;cout << s << endl;

}

Useful Operators

• + allows you to concatenate strings– string s1 = “Hello “ ;– string s2 = “ World”;– string s3 = s1 + s2; // s3 now has “Hello

World”

• += Short cut for concatenating– s1+= s2;

Equality Operators• Produce true or false values

string s1 = “Hello”;string s2 = “World”;s1 == s2 ; // produces falses1 != s2 ; // produces trues1 > s2; // produces false because W is greater in ascii than Hs1 < s2; // produces true for the same reason as above

• Also have • <= less than or equal• >= greater than or equal

Can be treated like an array• The subscript operator can be used to

return a characterstring str = “ABC”;char c = str[1]; // c now holds B

• Can also set a characterstring str = “ABC”;str[1] = ‘Z’; // str now has AZC

• Be careful setting characters• Make sure the string has some space first

string str;str[1] = ‘x’; // Not a good ideastr = “Hello”;str[1] = ‘a’; // works ok str now holds hallo

Useful Member Functions• length() & size () functions

– Both return the number of charactersstring str = "Hello";cout << str.size() << endl; // both output 5cout << str.length() << endl;

• c_str() returns a null terminated array of chars• A c string! Useful for older library functions that don’t

know what a string is

• erase(int start, int length);string str = "abcdefghi"; str.erase (5,3); cout << str12 << endl; // yields "abcdei"

find & rfind

• find(string &find, size_t pos) searches for the first occurrence of a string starting at pos.

• Returns the position of the 1st character of the found string

string s = “abcdefghi”string s1 = “def”;int pos = s.find(s1, 0); // returns the position of d in the string 3 in this case

• rfind does the same as find except that it finds the last occurrence

substr functions

• substr(int pos, int length)

• Returns a substring of the current string starting at pos with the specified length

string str = “abcdefghi”;string str1 = str.substr(6, 2); // str1 now holds “gh”

The getline function• getline(istream &is, string &str, char delim = ‘\n’);• Reads characters from an input stream into a

string, stopping when one of the following things happens:– An end-of-file condition occurs on the input

stream – When the maximum number of characters that

can fit into a string have been read – When a character read in from the string is equal

to the specified delimiter (newline is the default delimiter); the delimiter character is removed from the input stream, but not appended to the string.

More getline

• Returns a reference to the input stream. – If the stream is tested as a logical value (as in an if

or while), it is equivalent to true if the read was successful and false otherwise (e.g., end of file).

• The most common use of this function is to do "line by line" reads from a file.

• Remember that the normal extraction operator (>>) stops on white space, not necessarily the end of an input line.

• The getline function can read lines of text with embedded spaces.

getline example#include <iostream>#include <vector>#include <string>using namespace std;

Int main(){vector<string> vec1;string line;

vec1.clear(); ifstream infile ("stl2in.txt"); while (getline(infile,line,'\n')) { vec1.push_back (line); }

}

Dynamic memory allocation

• Until now, in our programs, we have only had as much memory as we have requested in declarations of variables– Array sizes have been fixed

• Not good because data in programs can grow and shrink as they run

• How do we dynamically allocate memory?– Through the use of new and delete operators

new • When we want to create memory we can

do so with newint *myArray; myArray = new int [5];

• Operating system will create a space in memory to hold 5 ints and return a pointer to the memory

What’s the difference

• Without new arrays size must be a constant – Means we need to decide size of arrays at

design time not execution time• dynamic memory allocation allows assigning

memory during the execution of the program using any variable, constant or combination of both as size.

Who manages memory• The dynamic memory is generally managed

by the operating system– in multitasking interfaces it can be shared

between several applications.• There is a possibility that the memory can be

depleted. – If the operating system cannot allocate the requested

memory, it returns a null pointer. – This means you should check for it:

int *myArraymyArray = new int [5]; if (myArray == NULL) { // error assigning memory. Take measures. };

The delete operator

• Once memory is no longer needed it should be freed – Make it available for future requests of

dynamic memory. – The operator delete exists for this purpose,

whose form is:

An Exampleinclude <iostream>#include <cstdlib> using namespace std;int main (){char input [100];int i,n;long *pArray;cout << "How many numbers do you want to type in? ";cin >> i;pArray = new long[i];if (pArray == NULL) exit (1);for (n=0; n<i; n++){ cout << "Enter number: "; cin >> pArray[n];}cout << "You have entered: ";for (n=0; n<i; n++) cout << pArray[n] << ", ";delete[] pArray;return 0;}

Memory Leaks• Happens when you forget to free a block

of memory allocated with the new operator or when you make it impossible to do so

• As a consequence your application may eventually run out of memory and may even cause the system to crash.

Leak example 1• Deleting memory before reallocating it

char *string; string = new char[20]; string = new char[30]; delete [] string;

How can we fix it and what exactly is the problem?

Leak example 2• Be sure to have a pointer to each dynamic

variable:char *first_string = new char[20];char *second_string = new char[20];strcpy(first_string, "leak");second_string = first_string;strcpy(second_string, first_string);delete [] second_string;

What happened is that the address of the dynamic variable associated with second_string (as a side-effect of the pointer assignment) is lost so we cannot delete it from the heap anymore. Thus the last line of code only frees the dynamic variable associated with first_string, which is not what we wanted.

Leak Example 3• Local pointers:

void leak() { int k; char *cp = new char('E'); delete cp;}

• What happens of cp is not deleted?• It seems that it would be destroyed when the

function returns• Actually the pointer is but not it’s memory

Singleton Classes

• Occasionally you want to create class that doesn’t need multiple instances– Address Book may be one of these

• Big question is why?– Allows you to get a reference to the single

instance that was created• Can be from anywhere

The static pointer• Singleton class uses a static pointer to

access the instance of the object– Remember static variables are declared on the

heap • Hold there value through the life of the program

– Defined as follows:

class addressBook{

private: static addressBook *pInstance;

}

Accessor Method

• Once you have created the static pointer– You need to create a public accessor method

to retrieve the pointer:

class addressBook{private: static addressBook *pInstance;public: static addressBook *Instance();

}

And the function Body

• Notice the declaration before the function– This is needed to create the pointer

addressBook * addressBook::pInstance = NULL;addressBook *addressBook::Instance(){

if(pInstance == NULL){

pInstance = new addressBook;}return pInstance;

}