Nhân bản – Phụng sự – Khai phóng
C/C++ Language Review
Data Structures & Algorithms
CONTENT
• Reminder of C/C++
• Structures
• Pointers
• Dynamic memory allocation
• Recursion
Data Structures & Algorithms 2
CONTENT
•Reminder of C/C++
• Structures
• Pointers
• Dynamic memory allocation
• Recursion
Data Structures & Algorithms 3
Reminder of C/C++
• Input • Control statements
• cin >> (C++) / scanf() (C) • if … else, switch … case
• Output • while, do … while, for
• break, continue
• cout << (C++) / printf() (C)
• Functions
• Data types
• References (C++)
• int, short, long
• Pointers
• float, double
• Arrays
• char
• bool (C++)/ C99 standard
• C-string
for C language • Files
• string (C++)
Data Structures & Algorithms 4
CONTENT
• Reminder of C/C++
•Structures
• Pointers
• Dynamic memory allocation
• Recursion
Data Structures & Algorithms 5
Structures
• Structure
• C/C++ construct that allows multiple variables to be grouped
together
• General Format
struct <StructName>{
type1 field1;
struct Student{
type2 field2;
. . . int studentID;
structure name
}; string name;
structure members short yearInSchool;
double gpa;
};
Example struct Declaration
Data Structures & Algorithms 6
…Structures
• Defining Variables & Accessing Members
• To define variables, use structure name as type name
Student stu1;
• Use the dot (.) operator to refer to fields/members of struct variables:
cin >> stu1.studentID;
getline(cin, stu1.name);
stu1.gpa = 3.75;
• Comparing struct Variables
• Cannot compare struct variables directly:
Student bill, william;
if (bill == william) // won’t work
• Instead, must compare on a field basis:
if (bill.studentID == william.studentID)...
Data Structures & Algorithms 7
…Structures
• Arrays of Structures
• Structures can be defined in arrays
• Can be used in place of parallel arrays
const int NUM_STUDENTS = 20;
Student stuList[NUM_STUDENTS];
• Individual structures accessible using subscript notation
• Fields within structures accessible using dot notation
cout << stuList[5].studentID;
Data Structures & Algorithms 8
…Structures
Data Structures & Algorithms 9
…Structures
• Nested Structures
• A structure can contain another structure as a member
struct PersonInfo
{ string name,
address,
city;
};
struct Student
{ int studentID;
PersonInfo pData;
short yearInSchool;
double gpa;
};
Data Structures & Algorithms 10
…Structures
• Members of Nested Structures
• Use the dot operator multiple times to refer to fields of nested
structures
Student s[10];
s[2].pData.name = "Joanne";
s[2].pData.city = "Tulsa";
Data Structures & Algorithms 11
…Structures
• Structures as Function Arguments
• May pass members of struct variables to functions
computeGPA(stu.gpa);
• May pass entire struct variables to functions
showData(stu);
• Can use reference parameter if function needs to modify contents
of structure variable
Data Structures & Algorithms 12
…Structures
• Example
Data Structures & Algorithms 13
…Structures
• Structures as Function Arguments – Notes
• Using value parameter for structure can slow down a program,
waste space
• Using a reference parameter will speed up program, but function
may change data in structure
• Using a const reference parameter allows read-only access to
reference parameter, does not waste space, speed
Data Structures & Algorithms 14
…Structures
• Revised showItem Function
Data Structures & Algorithms 15
…Structures
• Returning a Structure from a Function
• Function can return a struct
Student getStudentData(); // prototype
Student stu1;
stu1 = getStudentData(); // call
• Function must define a local structure
• for internal use
• for use with return statement
Data Structures & Algorithms 16
…Structures
• Example
Student getStudentData()
{ Student tempStu;
cin >> tempStu.studentID;
getline(cin, tempStu.pData.name);
getline(cin, tempStu.pData.address);
getline(cin, tempStu.pData.city);
cin >> tempStu.yearInSchool;
cin >> tempStu.gpa;
return tempStu;
}
Data Structures & Algorithms 17
CONTENT
• Reminder of C/C++
• Structures
•Pointers
• Dynamic memory allocation
• Recursion
Data Structures & Algorithms 18
Pointers
• Pointer is a special variable that stores address of another variable
• Definition
int *intptr;
• Read as
“intptr can hold the address of an int”
• Spacing in definition does not matter
int *intptr; // same as above
int* intptr; // same as above
Data Structures & Algorithms 19
…Pointers
• Assigning an address to a pointer variable
int *intptr;
intptr = #
• The indirection operator (*) dereferences a pointer
• It allows you to access the item that the pointer points to
int x = 25;
int *intptr = &x;
cout << *intptr << endl;
This prints 25
Data Structures & Algorithms 20
…Pointers
• Pointers to Structures
• A structure variable has an address
• Pointers to structures are variables that can hold the address of a
structure
Student *stuPtr;
• Can use & operator to assign address
stuPtr = & stu1;
• Structure pointer can be a function parameter
Data Structures & Algorithms 21
…Pointers
• Accessing Structure Members via Pointer Variables
• Must use () to dereference pointer variable, not field within
structure
cout << (*stuPtr).studentID;
• Can use structure pointer operator to eliminate () and use clearer
notation
cout << stuPtr->studentID;
Data Structures & Algorithms 22
…Pointers
• Example
Data Structures & Algorithms 23
CONTENT
• Reminder of C/C++
• Structures
• Pointers
•Dynamic memory allocation
• Recursion
Data Structures & Algorithms 24
Dynamic Memory Allocation
• Allocating storage for a variable while program is running
• Computer returns address of newly allocated variable
• Uses new operator to allocate memory (C++)
double *dptr;
dptr = new double;
new returns address of memory location
Data Structures & Algorithms 25
…Dynamic Memory Allocation
• Can also use new to allocate array
const int SIZE = 25;
arrayPtr = new double[SIZE];
• Can then use [] or pointer arithmetic to access array
for(i = 0; i < SIZE; i++)
*arrayptr[i] = i * i;
or
for(i = 0; i < SIZE; i++)
*(arrayptr + i) = i * i;
• Program will terminate if not enough memory available to allocate
Data Structures & Algorithms 26
…Dynamic Memory Allocation
• Releasing Dynamic Memory
• Use delete to free dynamic memory (C++)
delete dptr;
• Use [] to free dynamic array
delete [] arrayptr;
Data Structures & Algorithms 27
…Dynamic Memory Allocation
• malloc(size_t size) – C language
• Allocates size bytes and returns a pointer to the allocated memory.
• The memory is not cleared.
• free(void * p) – C language
• Frees the memory space pointed to by p, which must have been
returned by a previous call to malloc(), calloc(), or realloc().
• If free(p) has already been called before, undefined behavior occurs.
• If p is NULL, no operation is performed.
Data Structures & Algorithms 28
…Dynamic Memory Allocation
• Example
#include <stdlib.h>
...
int *p = malloc(sizeof(int) * 3);
p[0] = 10;
p[1] = 20;
p[2] = 30;
...
free(p);
Data Structures & Algorithms 29
…Dynamic Memory Allocation
C++ C
• Allocating memory • Allocating memory
• Operator new • Functions malloc(), calloc()
• Releasing memory • Releasing memory
• Operator delete • Function free()
• Operator delete [ ]
Data Structures & Algorithms 30
CONTENT
• Reminder of C/C++
• Structures
• Pointers
• Dynamic memory allocation
•Recursion
Data Structures & Algorithms 31
Recursion
• A recursive function contains a call to itself
void countDown(int num)
{
if (num == 0)
cout << ”Go!";
else
{
cout << num << "...\n";
countDown(num-1); //recursive call
}
}
Data Structures & Algorithms 32
…Recursion
• What happens when called?
first call to
countDown output:
num is 2
2...
countDown(1);
second call to
countDown
num is 1
void countDown(int num){ 1...
countDown(0);
if (num == 0)
cout << ”Go!"; third call to
countDown
else{ num is 0
cout << num << "...\n";
countDown(num-1); //recursive call // no Go!
} // recursive
} // call
Data Structures & Algorithms 33
…Recursion
• Recursive Functions - Purpose
• Recursive functions are used to reduce a complex problem to a
simpler-to-solve problem.
• The simplest-to-solve problem is solved directly
• The simplest-to-solve problem is known as the base case/
stopping case
• Recursive calls stop when the base case is reached
Data Structures & Algorithms 34
…Recursion
• Stopping the Recursion
• A recursive function must always include two cases
• a recursive call should be made until meeting the stopping case / base case
• the recursion should stop
• In the example, the stopping case is
if (num == 0)
Data Structures & Algorithms 35
…Recursion
• Stopping the Recursion
void countDown(int num)
if (num == 0)
cout << ”Go!";
else{
cout << num << "...\n";
countDown(num-1);// note that the value
} // passed to recursive
} // calls decreases by
// one for each call
Data Structures & Algorithms 36
…Recursion
• Example
• The factorial function
n! = n*(n-1)*(n-2)*...*3*2*1 if n > 0
n! = 1 if n = 0
• Can compute factorial of n if the factorial of (n-1) is known
n! = n * (n-1)!
• n = 0 is the base case
Data Structures & Algorithms 37
…Recursion
• Example
int factorial (int num){
if (num == 0)
return 1;
else
return num * factorial(num - 1);
}
Data Structures & Algorithms 38
…Recursion
• Fibonacci numbers
• Fibonacci numbers
0, 1, 1, 2, 3, 5, 8, 13, 21, ...
• After the starting 0,1, each number is the sum of the two
preceding numbers
• Recursive solution
fib(n) = fib(n – 1) + fib(n – 2)
• Base cases
n <= 0, n == 1
Data Structures & Algorithms 39
…Recursion
• Fibonacci numbers
–Example
int fib(int n){
if (n <= 0)
return 0;
else if (n == 1)
return 1;
else
return fib(n – 1) + fib(n – 2);
}
Data Structures & Algorithms 40
…Recursion
• The Towers of Hanoi
• The game uses three pegs A, B, C and a set of discs on peg A.
• The goal is to move the discs from peg A to peg C by satisfying the
following rules:
• Only one disc may be moved at a time.
• A disc cannot be placed on top of a smaller disc.
• A peg can be used as temporary peg while moving disc.
Data Structures & Algorithms 41
…Recursion
• The Towers of Hanoi - Moving Three Discs
Data Structures & Algorithms 42
…Recursion
• The Towers of Hanoi - Solution
• Suppose
• We know how to move n-1 discs
• Principle
• To move n discs from peg A to peg C:
• Move n–1 discs from peg A to peg B, using peg C as a temporary peg.
• Move the remaining disc from the peg A to peg C.
• Move n–1 discs from peg B to peg C, using peg A as a temporary peg.
Data Structures & Algorithms 43
…Recursion
• The Towers of Hanoi - Algorithm
Hanoi(n, A, B, C) { //move n discs from peg A to peg C
if (n == 1) // base case
move the disc from peg A to peg C;
else {
Hanoi(n-1, A, C, B);
move the big disc from peg A to peg C;
Hanoi(n-1, B, A, C);
}
}
Data Structures & Algorithms 44
…Recursion
• The Towers of Hanoi - Program
void Hanoi(int n, char A, char B, char C){
if (n == 1)
cout << “move the disc from peg ” << A
<< “ to peg “ << C << endl;
else {
Hanoi(n-1, A, C, B);
cout << “move the disc from peg ” << A
<< “ to peg “ << C << endl;
Hanoi(n-1, B, A, C);
}
}
Data Structures & Algorithms 45
SUMMARY
• Reminder of C/C++
• Structures
• Pointers
• Dynamic memory allocation
• Recursion
Data Structures & Algorithms 46
Nhân bản – Phụng sự – Khai phóng
Enjoy the Course…!
Data Structures & Algorithms 47
