260 likes | 364 Views
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”;
E N D
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 #include <iostream>#include <string>using namespace std; int main(){string s; cin >> s;cout << s << endl; } • You can use cin and cout with strings • << and >> are friends of the class
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 string s1 = “Hello”; string s2 = “World”; s1 == s2 ; // produces false s1 != s2 ; // produces true s1 > s2; // produces false because W is greater in ascii than H s1 < s2; // produces true for the same reason as above • Also have • <= less than or equal • >= greater than or equal Produce true or false values
Can be treated like an array string str = “ABC”;char c = str[1]; // c now holds B • Can also set a character string 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 idea str = “Hello”; str[1] = ‘a’; // works ok str now holds hallo The subscript operator can be used to return a character
Useful Member Functions string str = "Hello"; cout << str.size() << endl; // both output 5 cout << 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" • length() & size () functions • Both return the number of characters
find & rfind 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 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
substr functions string str = “abcdefghi”;string str1 = str.substr(6, 2); // str1 now holds “gh” substr(int pos, int length) Returns a substring of the current string starting at pos with the specified length
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 int *myArray; myArray = new int [5]; • Operating system will create a space in memory to hold 5 ints and return a pointer to the memory When we want to create memory we can do so with new
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 int *myArraymyArray = new int [5]; if (myArray == NULL) { // error assigning memory. Take measures. }; • 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:
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 Example include <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 char *string; string = new char[20]; string = new char[30]; delete [] string; How can we fix it and what exactly is the problem? Deleting memory before reallocating it
Leak example 2 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. Be sure to have a pointer to each dynamic variable:
Leak Example 3 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 Local pointers:
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 addressBook * addressBook::pInstance = NULL; addressBook *addressBook::Instance() { if(pInstance == NULL) { pInstance = new addressBook; } return pInstance; } • Notice the declaration before the function • This is needed to create the pointer