FSU COP3014 Final Jayarama

Conversion Specifiers

-A conversion specifier is a symbol that is used as a placeholder in a formatting string. For integer output (for example), %d is the specifier that holds the place for integers. Here are some commonly used conversion specifiers (not a comprehensive list): Specifier- Purpose: %d-int (signed decimal integer) %u-unsigned decimal integer %f-floating point values (fixed notation) - float, double %e-floating point values (exponential notation) %s-string %c-character

What is a Pointer?

-A pointer is a variable that stores a memory address. -Pointers are used to store the addresses of other variables or memory items. -Pointers are very useful for another type of parameter passing, usually referred to as Pass By Address. -Pointers are essential for dynamic memory allocation.

What is a Structure?

-A structure is a collection of data elements, encapsulated into one unit. -A structure definition is like a blueprint for the structure. It takes up no storage space itself - it just specifies what variables of this structure type will look like -An actual structure variable is like a box with multiple data fields inside of it. Consider the idea of a student database. One student record contains multiple items of information (name, address, SSN, GPA, etc) Properties of a structure: -internal elements may be of various data types -order of elements is arbitrary (no indexing, like with arrays) -Fixed size, based on the combined sizes of the internal elements

printf/scanf with C-strings

-An entire C-style string can be easily printed, by using the %s formatting symbol, along with the name of the char array storing the string (as the argument filling in that position): char greeting[] = "Hello"; printf("%s", greeting); // prints the word "Hello" -Be careful to only use this on char arrays that are being used as C-style strings. (This means, only if the null character is present as a terminator).

Accessing internal data using a pointer to a structure

-But if we use parentheses to force the dereference to happen first, then it works: (*fPtr).num = 10; // YES! -Alternative operator for pointers: While the above example works, it's a little cumbersome to have to use the parentheses and the dereference operator all the time. -So there is a special operator for use with pointers to structures. It is the arrow operator: pointerToStruct -> dataVariable -Example: Fraction * fPtr; // pointer to a fraction // assume this has been pointed at a valid target fPtr->num = 10; // set fraction's numerator to 10 fPtr->denom = 11; // denominator set to 11 cout << fPtr->num << '/' << fPtr->denom; // prints: 10/11

C vs. C++: Some important differences

-C has been around since around 1970 (or before) -C++ was based on the C language -While C is not actually a strict subset of C++, most C code can be handled by a C++ compiler -The older C-style way of including libraries looks like this: #include <stdio.h> #include <string.h> #include <math.h> #include <ctype.h> -The 4 different styles of casting are a C++ feature. C casts look like this double val = 5.783; int integer = (int) val;

Accessing members of nested structures

-Earlier, we saw an example of a structure variable used within another structure definition struct Date // Date is now a type name { int month; int day; int year; }; // so that "Date" is the type name struct Employee { char firstName[20]; char lastName[20]; Date hireDate; Date birthDate; };

Passing Stream Objects into Functions (2)

-Example of a more limited function: void Show() { cout << "Hello, World\n"; } -A call to this function always prints to standard output (cout). -Same function, more versatile: void Show(ostream& output) { output << "Hello, World\n"; } -We can do the printing to different output destinations now: Show(cout); // prints to standard output stream Show(cerr); // prints to standard error stream

Deallocation of dynamic memory (2)

-Example: int * list = new int[40]; // dynamic array delete [] list; // deallocates the array list = 0; // reset list to null pointer -After deallocating space, it's always a good idea to reset the pointer to null unless you are pointing it at another valid target right away. -To consider: So what happens if you fail to deallocate dynamic memory when you are finished with it? (i.e. why is deallocation important?)

Input/Ouput to and from files

-File input and file output is an essential in programming. -Most software involves more than keyboard input and screen user interfaces. -Data needs to be stored somewhere when a program is not running, and that means writing data to disk. -For this, we need file input and file output techniques. -Fortunately, this is EASY in C++! -If you know how to do screen output with cout, and keyboard input with cin, then you already know most of it! -File I/O with streams works the same way. The primary difference is that objects other than cout and cin will be used

User-entered file names

-File names don't have to be hard-coded as literal strings. We can get file names from other places (like user input, other files, etc), but we need to store them as cstrings. char filename[20]; -Filenames are usually in the form of a single word (C++ hates filenamrs with spaces). So we can just use the extraction operator to read it in. cin >> filename; -We can use this variable in the open() function when attaching a file to a stream: ofstream fout; fout.open(filename); -When error-checking to ensure that a valid file was attached, pick a technique that's appropriate to the situation. If the user just types a filename wrong, we might want to allow them to try again (instead of aborting the program).

Creating file stream objects, and attaching to files (2)

-File stream objects need to be attached to files before they can be used. Do this with a member function called open, which takes in the filename as an argument: // For ofstreams, these calls create brand new // files for output. For ifstreams, these calls // try to open existings files for input out1.open("outfile1.txt"); bob.open("clients.dat"); in1.open("infile1.txt"); joe.open("clients.dat"); Will open() always work?: -For an input file, what if the file doesn't exist? doesn't have read permission? -For an output file, what if the directory is not writable? What if it's an illegal file name?

Accessing members of nested structures (3)

-Here's an example of an employee initialization using our shortcut initializer form: Employee emp2 = { "John", "Smith", {6, 10, 2003}, {2, 19, 1981} }; // John Smith, whose birthday is Feb 19, 1981, was hired on June 10, 2003

Basics of Formatted Input/Output in C

-I/O is essentially done one character (or byte) at a time -stream - a sequence of characters flowing from one place to another -Input stream: data flows from input device (keyboard, file, etc) into memory -output stream: data flows from memory to output device (monitor, file, printer, etc) -Standard I/O streams (with built-in meaning) -stdin: standard input stream (default is keyboard) -stdout: standard output stream (defaults to monitor) -stderr: standard error stream -Formatted I/O - refers to the conversion of data to and from a stream of characters, for printing (or reading) in plain text format -All text I/O we do is considered formatted I/O -The other option is reading/writing direct binary information (common with file I/O, for example)

Application Example: Dynamically resizing an array

-If you have an existing array, and you want to make it bigger (add array cells to it), you cannot simply append new cells to the old ones. -Remember that arrays are stored in consecutive memory, and you never know whether or not the memory immediately after the array is already allocated for something else. -For that reason, the process takes a few more steps. -Here is an example using an integer array. Let's say this is the original array: int * list = new int[size]; -I want to resize this so that the array called list has space for 5 more numbers (presumably because the old one is full).

Notation: Pointer dereferencing (2)

-If you see the * in a declaration statement, with a type in front of the *, a pointer is being declared for the first time. -AFTER that, when you see the * on the pointer name, you are dereferencing the pointer to get to the target. -Pointers don't always have valid targets. -A pointer refers to some address in the program's memory space. -A program's memory space is divided up into segments -Each memory segment has a different purpose. Some segments are for data storage, but some segments are for other things, and off limits for data storage -If a pointer is pointing into an "out-of-bounds" memory segment, then it does NOT have a valid target (for your usage) -If you try to dereference a pointer that doesn't have a valid target, your program will crash with a segmentation fault error. This means you tried to go into an off-limits segment

Passing Stream Objects into Functions

-In a function prototype, any type can be used as a formal parameter type or as a return type. -This includes classes, which are programmer-defined types -Streams can be passed into functions as parameters (and/or returned). -Because of how the stream classes were set up, they can only be passed by reference, however -So, for instance, the following can be return types or parameter types in a function: ostream & istream & ofstream & ifstream & -Why? - functions that do output can be written that are more versatile, by allowing the output to go to a variety of places

structs and enums

-In both C and C++, the struct definition is the same. -In C++, declaring a struct or an enum automatically creates a new type. -In C, we need to remind the compiler about the user-defined type every time we use it. -We can define a new type in C using the typedef keyword. typedef struct student // structure "tag" { char name[20]; double gpa; } Student; // this is now the new type name struct student s1; // C declaration using "tag" Student s2; // C declaration using new type name

Legal variations in declaration syntax (2)

-In fact, if you only want structure variables, but don't plan to re-use the structure type (i.e. the blueprint), you don't even need a structure name: struct // note: no structure NAME given { int num; int denom; } f1, f2, f3; // three variables representing fractions -Of course, the advantage of giving a structure definition a name is that it is reusable. It can be used to create structure variables at any point later on in a program, separate from the definition block.

Pointer Arithmetic

-In the above array example, we referred to an array item with p[6]. We could also say *(p+6). -When you add to a pointer, you do not add the literal number. You add that number of units, where a unit is the type being pointed to. -For instance, p + 6 in the above example means to move the pointer forward 6 integer addresses. Then we can dereference it to get the data *(p + 6). -Most often, pointer arithmetic is used with arrays. -Suppose ptr is a pointer to an integer, and ptr stores the address 1000. Then the expression (ptr + 5) does not give 1005 (1000+5). -Instead, the pointer is moved 5 integers (ptr + (5 * size-of-an-int)). So, if we have 4-byte integers, (ptr+5) is 1020 (1000 + 5*4)

Assigning Pointers of the same type

-It is also legal to assign one pointer to another, provided that they are the same type: int * ptr1, * ptr2; // two pointers of type int ptr1 = ptr2; // can assign one to the other // now they both point to the same place -Although all pointers are addresses (and therefore represented similarly in data storage), we want the type of the pointer to indicate what is being pointed to. Therefore, C treats pointers to different types AS different types themselves. int * ip; // pointer to int char * cp; // pointer to char double * dp; // pointer to double

Passing structures into and out of functions

-Just like a variable of a basic type, a structure can be passed into functions, and a structure can be returned from a function. -To use structures in functions, use structname as the parameter type, or as a return type, on a function declaration Examples (assuming struct definition examples from previous page): // function that passes a structure //variable as a parameter void PrintStudent(Student s); // function that passes in structure variables // and returns a struct Fraction Add(Fraction f1, Fraction f2);

Pass by value, reference, address

-Just like with regular variables, structures can be passed by value or by reference, or a pointer to a structure can be passed (i.e. pass by address) -If just a plain structure variable is passed, as in the above examples, it's pass by value. A copy of the structure is made -To pass by reference, use the & on the structure type, just as with regular data types -To pass by address, use pointers to structures as the parameters and/or return -As with pointers to the built-in types, you can use const to ensure a function cannot change the target of a pointer -It's often a GOOD idea to pass structures to and from functions by address or by reference -structures are compound data, usually larger than plain atomic variables -Pass-by-value means copying a structure. NOT copying is desirable for efficiency, especially if the structure is very large

Structures and the assignment operator (2)

-Note that in the above example, the two assignment statements are equivalent to doing the following: // these 4 lines are equivalent to s1 = s2; strcpy(s1.fName, s2.fName); strcpy(s1.lName, s2.lName); s1.socSecNumber = s2.socSecNumber; s1.gpa = s2.gpa; //these 2 lines are equivalent to f1 = f2; f1.num = f2.num; f1.denom = f2.denom; -Clearly, direct assignment between entire structures is easier, if a full copy of the whole thing is the desired result!

Using file streams

-Once a file stream object is attached to a file, it can be used with the same syntax as cin and cout (for input and output streams, respectively) -Input file stream usage is like cin: int x, y, z; double a, b, c; in1 >> x >> y >> z; //read 3 ints from the file in1 >> a >> b >> c; // read 3 doubles from file -Output file stream usage is like cout: out1 << "Hello, World\n"; // print "Hello, World" // to the file out1 << "x + y = " << x + y; // print a math //result to the file

Notation: Pointer dereferencing

-Once a pointer is declared, you can refer to the thing it points to, known as the target of the pointer, by "dereferencing the pointer". To do this, use the unary * operator: int * ptr; // ptr is now a pointer-to-int // Notation: // ptr refers to the pointer itself // *ptr the dereferenced pointer -- refers now to the TARGET -Suppose that ptr is the above pointer. Suppose it stores the address 1234. Also suppose that the integer stored at address 1234 has the value 99. cout << "The pointer is: " << ptr; // prints the pointer cout << "The target is: " << *ptr; // prints the target Note: the exact printout of an addres may vary based on the system.

Using structures

-Once a structure variable is created, how do we use it? How do we access its internal variables (often known as itsmembers)? -To access the contents of a structure, we use the dot-operator. Format: structVariableName.dataVariableName Example, using the fraction structure: Fraction f1, f2; f1.num = 4; // set f1's numerator to 4 f1.denom = 5; // set f1's denominator to 5 f2.num = 3; // set f2's numerator to 3 f2.denom = 10; // set f2's denominator to 10 cout << f1.num << '/' << f1.denom; // prints 4/5 cout << f2.num << '/' << f2.denom; // prints 3/10

Pass by Address with arrays (3)

-Pass-by-address can be done in returns as well - we can return the address of an array. int * ChooseList(int * list1, int * list2) { if (list1[0] < list2[0]) return list1; else return list2; // returns a copy of the address of the array } And an example usage of this function: int numbers[5] = 1,2,3,4,5; int numList[3] = 3,5,7; int * p; p = ChooseList(numbers, numList);

Declaring Pointers

-Pointer declarations use the * operator. They follow this format: -typeName * variableName; int n; // declaration of a variable n int * p; // declaration of a pointer, called p -In the example above, p is a pointer, and its type will be specifically be referred to as "pointer to int", because it stores the address of an integer variable. We also can say its type is: int* -The type is important. While pointers are all the same size, as they just store a memory address, we have to know what kind of thing they are pointing TO. double * dptr; // a pointer to a double char * c1; // a pointer to a character float * fptr; // a pointer to a float

The "address of" operator

-Recall, the & unary operator, applied to a variable, gives its address: int x; // the notation &x means "address of x" -This is the best way to attach a pointer to an existing variable: int * ptr; // a pointer int num; // an integer ptr = &num; // assign the address of num to ptr // now ptr points to "num"!

printf/scanf with C-strings

-Similarly, you can read a string into a char array with scanf. The following call allows the entry of a word (up to 19 characters and a terminating null character) from the keyboard, which is stored in the array word1: char word1[20]; scanf("%s", word1); -Characters are read from the keyboard until the first "white space" (space, tab, newline) character is encountered. The input is stored in the character array and the null character is automatically appended. -Note also that the & was not needed in the scanf call (word1 was used, instead of &word1). This is because the name of the array by itself (with no index) actually IS a variable that stores an address (a pointer).

Creating file stream objects, and attaching to files (3)

-Since it's possible for open() to fail, one should always check to make sure there's a valid file attached -One way is to test the value of the stream object. A stream that is not attached to a valid file will evaluate to "false" //if in1 not attached to a valid source, abort if (!in1) { cout << "Sorry, bad file."; exit(0); // system call to abort program // may require <cstdlib> to be included } -When finished with a file, it can be detached from the stream object with the member function close(): in1.close(); -The close function simply closes the file. It does not get rid of the stream object. The stream object can now be used to attach to another file, if desired

Declaring Pointers (2)

-Since the type of a "pointer-to-int" is (int *), we might ask, does this create three pointers? int* p, q, r; // what did we just create? NO! This is not three pointers. Instead, this is one pointer and two integers. If you want to create mulitple pointers on one declaration, you must repeat the * operator each time

Reading Strings (files)

-So far, we have used cin as the input stream for reading strings. -If we're reading strings from a file, we can use the input file stream instead. -Assuming the input stream is called in1 and it is attached to a valid input file, //reading in a cstring char value[100]; in1.getline(value, 100, '\n'); //reading in a string object string text; getline(in1, text, '\n');

Accessing dynamically created space

-So once the space has been dynamically allocated, how do we use it? -For single items, we go through the pointer. Dereference the pointer to reach the dynamically created target: int * p = new int; // dynamic integer, pointed to by p *p = 10; // assigns 10 to the dynamic integer cout << *p; // prints 10 -For dynamically created arrays, you can use either pointer-offset notation, or treat the pointer as the array name and use the standard bracket notation: double * numList = new double[size]; for (int i = 0; i < size; i++) numList[i] = 0; // initialize elements to 0 numList[5] = 20; // bracket notation *(numList + 7) = 15; // pointer-offset notation

Creating Structure definitions and variables

-Structure Definitions The basic format of a structure definition is: struct structureName { // data elements in the structure }; struct is a keyword -The data elements inside are declared as normal variables. structureName becomes a new type. -Note that the two examples below are both just blueprints specifying what will be in corresponding structure variables if and when we create them. -By themselves, these definitions above are not variables and do not take up storage I Fraction and Student can now be used as new type names

Output with printf

-The basic format of a printf function call is: printf (format string, list of expressions); where: -format string is the layout of what's being printed -list of expressions is a comma-separated list of variables or expressions yielding results to be inserted into the output -To output string literals, just use one parameter on printf, the string itself printf("Hello, world!\n"); printf("Greetings, Earthling\n\n");

Opening a file in 'append mode'

-The default way for opening an output file is to create a brand new file and begin writing from the beginning -If another file with the same name already exists, it will be overwritten! -Existing files can be opened for output, so that the new output is tacked on to the end. This is called appending. -To open a file in append mode, we use an extra parameter in the open() function: ofstream fout; // create file stream fout.open("file.txt", ios::app); // open file in append mode -There are a number of special constants like this one (ios::app). This one will cause a file to be opened for appending

Legal variations in declaration syntax

-The definition of a structure and the creation of variables can be combined into a single declaration, as well. -Just list the variables after the structure definition block (the blueprint), and before the semi-colon: struct structureName { // data elements in the structure } variable1, variable2, ... , variableN; Example: struct Fraction { int num; // the numerator of the fraction int denom; // the denominator of the fraction } f1, fList[10], *fptr; // variable, array, and pointer created

Pass By Address with arrays

-The fact that an array's name is a pointer allows easy passing of arrays in and out of functions. When we pass the array in by its name, we are passing the address of the first array element. So, the expected parameter is a pointer. Example: // This function receives two integer pointers, // which can be names of integer arrays. int Example1(int * p, int * q); -When an array is passed into a function (by its name), any changes made to the array elements do affect the original array, since only the array address is copied (not the array elements themselves). void Swap(int * list, int a, int b) { int temp = list[a]; list[a] = list[b]; list[b] = temp; }

Using const with pass-by-address

-The keyword const can be used on pointer parameters, like we do with references. -It is used for a similar situation - it allows parameter passing without copying anything but an address, but protects against changing the data (for functions that should not change the original) -The format: const typeName * v -This establishes v as a pointer to an object that cannot be changed through the pointer v. -Note: This does not make v a constant! The pointer v can be changed. But, the target of v cannot be changed (through the pointer v). -Example: int Function1(const int * list); // the target of //list can't be changed in the function

Allocating space with new (2)

-The new operator returns the starting address of the allocated space, and this address can be stored in a pointer: int * p; // declare a pointer p p = new int; //dynamically allocate an int and load address into p double * d; // declare a pointer d d = new double; // dynamically allocate a double and load address into d // we can also do these in single line statements int x = 40; int * list = new int[x]; float * numbers = new float[x+10]; Notice that this is one more way of initializing a pointer to a valid target (and the most important one).

The null pointer (2)

-The null pointer is never a valid target, however. If you try to dereference the null pointer, you WILL get a segmentation fault. -So why use it? The null pointer is typically used as a placeholder to initialize pointers until you are ready to use them (i.e. with valid targets), so that their values are known. -If a pointer's value was completely unknown - random memory garbage - you'd never know if it was safe to dereference -If you make sure your pointer is ALWAYS set to either a valid target, or to the null pointer, then you can test for it: if (ptr != 0) // safe to dereference cout << *ptr

Struct Vs. Class

-The only difference between a class and a struct in C++ is that structs have default public members and bases and classes have default private members and bases. Both classes and structs can have a mixture of public and private members, can use inheritance, and can have member functions.

Using const with pass-by-address (2)

-The pointer can be made constant, too. Here are the different combinations: 1. Non-constant pointer to non-constant data int * ptr; 2. Non-constant pointer to constant data const int * ptr; 3. Constant pointer to non-constant data int x = 5; int * const ptr = &x; // must be initialized here -An array name is this type of pointer - a constant pointer (to non-constant data). 4. Constant pointer to constant data int x = 5; const int * const ptr = & x;

Character I/O- Input

-There are many versions of the extraction operator >>, for reading data from an input stream. This includes a version that reads characters: char letter; cin >> letter; -However, if we, for example, tried to copy a file into another by reading one character at a time, the output file wouldn't have any whitespace. -All built-in versions of the extraction operator for input streams will ignore leading white space by default

Reinterpret Cast (pointers)

-These three pointer variables (ip, dp, cp) are all considered to have different types, so assignment between any of them is illegal. The automatic type coercions that work on regular numerical data types do not apply: ip = dp; // ILLEGAL dp = cp; // ILLEGAL ip = cp; // ILLEGAL -As with other data types, you can always force a coercion by performing an explicit cast operation. With pointers, you would usually use reinterpret cast. Be careful that you really intend this, however! ip = reinterpret cast<int* >(dp);

Pass By Address with arrays (2)

-This Swap function allows an array to be passed in by its name only. The pointer is copied but not the entire array. So, when we swap the array elements, the changes are done on the original array. Here is an example of the call from outside the function: int numList[5] = 2, 4, 6, 8, 10; Swap(numList, 1, 4); // swaps items 1 and 4 -Note that the Swap function prototype could also be written like this: void Swap(int list[], int a, int b); -The array notation in the prototype does not change anything. An array passed into a function is always passed by address, since the array's name IS a variable that stores its address (i.e. a pointer).

Passing Stream Objects into Functions (3)

-This works with file stream types, too: void PrintRecord(ofstream& fout, int acctID, double balance) { fout << acctID << balance << '\n'; } -Now, we can call this function to print the same data format to different files: ofstream out1, out2; out1.open("file1.txt"); out2.open("file2.txt"); PrintRecord(out1, 12, 45.6); //print to file1 PrintRecord(out1, 124, 67.89); // print to file1 PrintRecord(out2, 100, 123.09); // print to file2 PrintRecord(out2, 11, 287.64); // print to file2

Allocating space with new

-To allocate space dynamically, use the unary operator new, followed by the type being allocated. new int; // dynamically allocates an int new double; // dynamically allocates a double -If creating an array dynamically, use the same form, but put brackets with a size after the type: new int[40]; // dynamically allocates an array of 40 ints new double[size]; // dynamically allocates an array of size doubles // note that the size can be a variable -These statements above are not very useful by themselves, because the allocated spaces have no names!

Structure Variables

-To create an actual structure variable, use the structure's name as a type, and declare a variable from it. Format: structureName variableName; -Variations on this format include the usual forms for creating arrays and pointers, and the comma-separated list for multiple variables Examples: Fraction f1; // f1 is now a 'Fraction' Fraction fList[10]; // an array of 'Fraction' //structures Fraction * fptr; // a pointer to a 'Fraction' //structure Student stu1; // a Student structure variable Student mathclass[10]; // an array of 10 Students Student s1, s2, s3; // three Student variables

Deallocation of dynamic memory

-To deallocate memory that was created with new, we use the unary operator delete. -The one operand should be a pointer that stores the address of the space to be deallocated: int * ptr = new int; // dynamically created int // ... delete ptr; // deletes the space that ptr points to -Note that the pointer ptr still exists in this example. That's a named variable subject to scope and extent determined at compile time. It can be reused: ptr = new int[10]; // point p to a brand new array -To deallocate a dynamic array, use this form: delete [] name of pointer;

Printing Integers (2)

-To left justify, use a negative number in the field width printf("FSU has %-10d students", numStudents); // Output: // FSU has 35123 students -If the field width is too small or left unspecified, it defaults to the minimum number of characters required to print the item: printf("FSU has %2d students", numStudents); // Output: // FSU has 35123 students -Specifying the field width is most useful when printing multiple lines of output that are meant to line up in a table format

Printing Integers

-To output an integer, use %d in the format string, and an integer expression in the list of expressions. int numStudents = 35123; printf("FSU has %d students", numStudents); // Output: // FSU has 35123 students -We can specify the field width (i.e. how many 'spaces' the item prints in). Defaults to right-justification. Place a number between the % and the d. In this example, field width is 10: printf("FSU has %10d students", numStudents); // Output: // FSU has 35123 students

Printing Floating-point numbers

-Use the %f modifer to print floating point values in fixed notation: double cost = 123.45; printf("Your total is $%f today\n", cost); // Output: // Your total is $123.450000 today -Use %e for exponential notation: printf("Your total is $%e today\n", cost); // Output: // Your total is $1.234500e+02 today -Note that the e+02 means "times 10 to the 2nd power"

Printing characters and strings

-Use the formatting specifier %c for characters. Default field size is 1 character: char letter = 'Q'; printf("%c%c%c\n", '*', letter, '*'); // Output is: *Q* -Use %s for printing strings. Field widths work just like with integers: printf("%s%10s%-10sEND\n", "Hello", "Alice", "Bob"); // Output: // Hello AliceBob END

Dynamic Memory Allocation

-We can dynamically allocate storage space while the program is running, but we cannot create new variable names "on the fly" -For this reason, dynamic allocation requires two steps: 1. Creating the dynamic space. 2. Storing its address in a pointer (so that the space can be accesed) -To dynamically allocate memory in C++, we use the new operator. De-allocation: -Deallocation is the "clean-up" of space being used for variables or other data storage -Compile time variables are automatically deallocated based on their known extent (this is the same as scope for "automatic" variables) -It is the programmer's job to deallocate dynamically created space -To de-allocate dynamic memory, we use the delete operator

Structures Motivation

-We have plenty of simple types for storing single items like numbers, characters. But is this really enough for storing more complex things, like patient records, address books, tables, etc.? -It would be easier if we had mechanisms for building up more complex storage items that could be accessed with single variable names -Compound Storage - there are some built-in ways to encapsulate multiple pieces of data under one name -Array - we already know about this one. Indexed collections, and all items are the same type -Structure - keyword struct gives us another way to encapsulate multiple data items into one unit. In this case, items do not have to be the same type -Structures are good for building records - like database records, or records in a file.

Character I/O - Output

-We've already used the insertion operator to print characters: char letter = 'A'; cout << letter; -There is also a member function (of output stream classes) called put(), which can be used to print a character. It's prototype is: ostream& put(char c); -Sample calls: char ch1 = 'A', ch2 = 'B', ch3 = 'C'; cout.put(ch1); // equivalent to: cout << ch1; cout.put(ch2); // equivalent to: cout << ch2; -It can be cascaded, like the insertion operator: cout.put(ch1).put(ch2).put(ch3); -The put() function doesn't really do anything more special than the insertion operator does. It's just listed here for completeness

const pointers and C-style strings

-We've seen how to declare a character array and initialize with a string: char name[25] = "Spongebob Squarepants"; -Note that this declaration creates an array called name (of size 25), which can be modified. -Another way to create a varible name for a string is to use just a pointer: char* greeting = "Hello"; -However, this does NOT create an array in memory that can be modified. Instead, this attaches a pointer to a fixed string, which is typically stored in a "read only" segment of memory (cannot be changed). -So it's best to use const on this form of declaration: const char* greeting = "Hello"; // better

Pass By Address

-We've seen that regular function parameters are pass-by-value -A formal parameter of a function is a local variable that will contain a copy of the argument value passed in -Changes made to the local parameter variable do not affect the original argument passed in -If a pointer type is used as a function parameter type, then an actual address is being sent into the function instead -In this case, you are not sending the function a data value -instead, you are telling the function where to find a specific piece of data -Such a parameter would contain a copy of the address sent in by the caller, but not a copy of the target data -When addresses (pointers) are passed into functions, the function could affect actual variables existing in the scope of the caller

A shortcut for initializing structs

-While we can certainly initialize each variable in a structure separately, we can use an initializer list on the declaration line, too -This is similar to what we saw with arrays -This is only usable on the declaration line (like with arrays) -The initializer set should contain the struct contents in the same order that they appear in the struct definition Example (using the fraction structure): Fraction f1 = 3, 5; //initialize num=3, denom=5 // This would be the same as doing the following: f1.num = 3; f1.denom = 5; Example (using the student structure): Student s1 = {"John", "Smith", 123456789, 3.75}; Student s2 = {"Alice", "Jones", 123123123, 2.66};

Pointers and Arrays

-With a regular array declaration, you get a pointer for free. The name of the array acts as a pointer to the first element of the array. int list[10]; // the variable list is a pointer // to the first integer in the array int * p; // p is a pointer. same type as list. p = list; // legal assignment. Both pointers to ints. -In the above code, the address stored in list has been assigned to p. Now both pointers point to the first element of the array. Now, we could actually use p as the name of the array! list[3] = 10; p[4] = 5; cout << list[6]; cout << p[6];

Structures and the assignment operator

-With regular primitive types we have a wide variety of operations available, including assignment, comparisons, arithmetic, etc. -Most of these operations would NOT make sense on structures. Arithmetic and comparisons, for example: Student s1, s2; s1 = s1 + s2; // ILLEGAL! // How would we add two students, anyway? if (s1 < s2) // ILLEGAL. What would this mean?// yadda yadda -Using the assignment operator on structures IS legal, as long as they are the same type. Example (using previous struct definitions): Student s1, s2; Fraction f1, f2; s1 = s2; // LEGAL. Copies contents of s2 into s1 f1 = f2; // LEGAL. Copies f2 into f1

Printing Floating-point numbers (2)

-You can also control the decimal precision, which is the number of places after the decimal. Output will round to the appropriate number of decimal places, if necessary: printf("Your total is $%.2f today\n", cost); // Output: // Your total is $123.45 today -Field width can also be controlled, as with integers: printf("Your total is $%9.2f today\n", cost); // Output: // Your total is $ 123.45 today -n the conversion specifier, the number before the decimal is field width, and the number after is the precision. (In this example, 9 and 2).

Legal variations in declaration syntax (3)

-You can even declare structures as variables inside of other structure defintions (of different types): struct Date // a structure to represent a date { int month; int day; int year; }; struct Employee // a structure to represent an employee of a company { char firstName[20]; char lastName[20]; Date hireDate; Date birthDate; };

The null pointer

-special pointer whose value is 0 -You can assign 0 into a pointer: ptr = 0; -The null pointer is the only integer literal that may be assigned to a pointer. You may NOT assign arbitrary numbers to pointers: nt * p = 0; // OK assignment of null pointer to p int * q; q = 0; // okay. null pointer again. int * z; z = 900; // BAD! cannot assign other literals to pointers! double * dp; dp = 1000; // BAD!

Creating Structure definitions and variables (Example)

/* A structure representing the parts of a fraction (a rational number) */ struct Fraction { int num; // the numerator of the fraction int denom; // the denominator of the fraction }; /* A structure representing a record in a student database */ struct Student { char fName[20]; // first name char lName[20]; // last name int socSecNumber; // social security number double gpa; // grade point average };

Pass by value, reference, address (Examples)

// function that passes a pointer to student //structure as a parameter void GetStudentData(Student* s); // function that passes in structures by const // reference, and returns a struct by value Fraction Add(const Fraction& f1, const Fraction& f2); //function that uses const on a structure pointer // parameter. This function could take in an array // of Students, or the address of one student. void PrintStudents(const Student* s); // or, this prototype is equivalent to the one above void PrintStudents(const Student s[]);

eof() member function

A useful member function of the input stream classes is eof(): -Stands for end of file -Returns a bool value, answering the question "Are we at the end of the file?" (or is the "end-of-file" character the next one on the stream?) -Can be used to indicate whether the end of an input file has been reached, when reading sequentially -Very useful when reading files where the size of the file or the amount of data to be read is not known in advance while (!in1.eof()) // while not at end of file { // read and process input from the file } -Can also be used with cin, where the user types a key combination representing the "end-of-file" character -On Unix and Mac systems, type ctrl-d to enter the end-of-file character -On Windows, type ctrl-z to enter the end-of-file character

scanf Basics (2)

Conversion Specifiers: -Mostly the same as for output. Some small differences -Use %f for type float, but use %lf for types double and long double -The data type read, the conversion specifier, and the variable used need to match in type -White space is skipped by default in consecutive numeric reads. But it is not skipped for character/string inputs.

Kinds of Files

Formatted Text vs. Binary files: -A text file is simply made of readable text characters. -It looks like the output that is typically printed to the screen through the cout object -A binary file contains unformatted data, saved in its raw memory format. (For example, the integer 123456789 is saved as a 4-byte chunk of data, the same as it's stored in memory - NOT as the 9 digits in this sentence). Sequential vs. Random Access files: -A sequential file is one that is typically written or read from start to finish -A random access file is one that stores records, all of the same size, and can read or write single records in place, without affecting the rest of the file -For now, we'll deal with sequential text files

Character I/O- Input (2)

Here are some other useful member functions (of input stream classes) for working with the input of characters: -peek() - this function returns the ascii value of the next character on the input stream, but does not extract it -get() - the two get functions both extract the next single character on the input stream, and they do not skip any white space. -The version with no parameters returns the ascii value of the extracted character -The version with the single parameter stores the character in the parameter, passed by reference. Returns a reference to the stream object (or 0, for end-of-file) -ignore() member function - skips either a designated number of characters, or skips up to a specified delimiter. -putback() member function - puts a character back into the input stream

Accessing members of nested structures (2)

Here's an example of initializing all the data elements for one employee variable: Employee emp; // emp is an employee variable // Set the name to "Alice Jones" strcpy(emp.firstName, "Alice"); strcpy(emp.lastName, "Jones"); // set the hire date to March 14, 2001 emp.hireDate.month = 3; emp.hireDate.day = 14; emp.hireDate.year = 2001; // sets the birth date to Sept 15, 1972 emp.birthDate.month = 9; emp.birthDate.day = 15; emp.birthDate.year = 1972;

Pointers & Structures

If we have a pointer to a structure, things are a little trickier: Fraction f1; // a fraction structure Fraction *fPtr; // pointer to a fraction fPtr = &f1; // fPtr now points to f1 f1.num = 3; // this is legal, of course fPtr.num = 10; // how about this? NO! ILLEGAL // cannot put a pointer on the left side // of the dot-operator -Remember that to get to the target of a pointer, we dereference it. The target of fPtr is *fPtr. So how about this? *fPtr.num = 10; // closer, but still NO (not quite) -The problem with this is that the dot-operator has higher precedence, so this would be interpreted as: *(fPtr.num) = 10; // cannot put a pointer on the left of the dot

lexicographical order

Numbers first, then uppercase letters, then lowercase

C vs. C++: Some important differences (2)

Some of the C++-Only features are: -The Boolean type -Classes and Objects -namespaces and using statements -exception handling (with try, catch, throw) -using new and delete for dynamic memory management -templates -Function Overloading -Pass by reference -Default parameters

Example, using the student structure:

Student sList[10]; // array of 10 students // set first student's data: (John Smith, SSN: 123456789, GPA: 3.75) strcpy(sList[0].fName, "John"); strcpy(sList[0].lName, "Smith"); sList[0].socSecNumber = 123456789; sList[0].gpa = 3.75; // assume there's more code here that initializes other students // This loop prints all 10 students -- their names and their GPA cout << fixed << setprecision(2); for (int i = 0; i < 10; i++) { cout << sList[i].fName << ' ' << sList[i].lName << ' ' << sList[i].gpa << '\n'; }

Application Example: Dynamically resizing an array (2)

There are four main steps. 1. Create an entirely new array of the appropriate type and of the new size. (You'll need another pointer for this). int * temp = new int[size + 5]; 2. Copy the data from the old array into the new array (keeping them in the same positions). This is easy with a for-loop. for (int i = 0; i < size; i++) temp[i] = list[i]; 3. Delete the old array - you don't need it anymore! delete [] list; // this deletes the array pointed to by "list" 4. Change the pointer. You still want the array to be called "list" (its original name), so change the list pointer to the new address. list = temp;

Allocating memory

There are two ways that memory gets allocated for data storage: 1. Compile Time (or static) Allocation -Memory for named variables is allocated by the compiler -Exact size and type of storage must be known at compile time -For standard array declarations, this is why the size has to be constant 2. Dynamic Memory Allocation -Memory allocated "on the fly" during run time -Dynamically allocated space usually placed in a program segment known as the heap or the free store -Exact amount of space or number of items does not have to be known by the compiler in advance. -For dynamic memory allocation, pointers are crucial

scanf basics

To read data in from standard input (keyboard), we call the scanf function. The basic form of a call to scanf is: scanf(format string, list of variable addresses); -The format string is like that of printf -But instead of expressions, we need space to store incoming data, hence the list of variable addresses -If x is a variable, then the expression &x means "address of x" -scanf example: int month, day; printf("Please enter your birth month, followed by the day: "); scanf("%d %d", &month, &day);

Datatype Sizes

Type Size bool , char , unsigned char , signed char , __int8 -1 byte __int16 , short , unsigned short , wchar_t , __wchar_t -2 bytes float , __int32 , int , unsigned int , long , unsigned long -4 bytes double , __int64 , long double , long long -8 bytes

Pointer Arithmetic Operations

What pointer arithmetic operations are allowed? -A pointer can be incremented (++) or decremented (-) -An integer may be added to a pointer (+ or +=) -An integer may be subtracted from a pointer (- or -=) -One pointer may be subtracted from another

Character I/O- Input (Examples)

char ch1, ch2, ch3; cin >> ch1 >> ch2 >> ch3; // reads three characters, skipping white space //get(): no parameters, no white space skipped ch1 = cin.get(); ch2 = cin.get(); ch3 = cin.get(); //get(): one parameter, can be cascaded cin.get(ch1).get(ch2).get(ch3); //peek(): trying to read a digit, as a char char temp = cin.peek(); // look at next character if (temp < '0' || temp > '9') cout << "Not a digit"; else ch1 = cin.get(); // read the digit

Creating file stream objects, and attaching to files

cout and cin are objects: -cout is the standard output stream, usually representing the monitor. It is of type ostream -cin is the standard input stream, usually representing the keyboard. It is of type istream ostream and istream are classes -If you were to have declared them, you might have written: ostream cout; istream cin; -To create file stream objects, we need to include the <fstream>library: #include <fstream> using namespace std; -This library has classes ofstream ("output file stream") and ifstream ("input file stream"). Use these to declare file stream objects: // create file output streams out1 and bob ofstream out1, bob; // create file input streams, called in1 and joe ifstream in1, joe;

Initializing Pointers

int * ptr; ptr = ; // with what can we fill this blank? -The null pointer -Pointers of the same type -The "address of" operator -Reinterpreted pointer of a different type -Address to a dynamically allocated chunk of memory.

C I/O

stdio.h - contains basic I/O functions -scanf: reads from standard input (stdin) -printf: writes to standard output (stdout) -There are other functions similar to printf and scanf that write to and read from other streams -How to include, for C or C++ compiler #include <stdio.h> // for a C compiler #include <cstdio> // for a C++ compile

Example (Pass By Address)

void SquareByAddress(int * ptr) // Note that this function doesn't return anything. { *ptr=(*ptr) * (*ptr); // modifying target, *ptr } int main() { int num = 4; cout << "num = " << num << '\n'; // num = 4 SquareByAddress(&num); // address of num passed cout << "num = " << num << '\n'; // num = 16 }