CS102 Software Engineering Principles

Transcription

1 CS102 Software Engineering Principles Bill Cheng 1

2 Software Engineering Principles You need to develop a plan before you start writing your code Choose the proper data structures Consider what objects you need & how they interact Consider different approaches & their efficiency At some point your code will be too large to fit in your brain all at once CSCI 102 will intentionally push you past this limit From Lab #2 and HW #1 onward, we will start requiring a small design document Let s talk briefly about some software design methodologies 2

3 Waterfall Development Requirements What should the software do? Design How will you meet the reqs? Implementation Write the code Veritifcation Test the code Maintenance Keep it working 3

4 Iterative Development Don t try to do everything at once...go through each stage as many times as necessary! Requirements Analysis & Design Planning Implementation Initial Planning Deployment Evalutaion Testing 4

5 Extreme/Agile Programming XP Practices Whole Team Customer Tests Collective Ownership Pair Programming Continuous Integration Test-driven Development Simple Design Metaphor Coding Standard Refactoring Sustainable Pace Planning Game Small Releases Program in pairs? Write tests first? Weird 5

6 Design Documents From this point onward... All your homework assignments will require a design document to be submitted with your code Most of your lab assignments will require a design document to be submitted Lab design documents must be submitted BEFORE you turn in your lab There is a design document template available on the course website There are links on the main homework & lab pages 6

7 CS102 Basic C++ Memory Management Bill Cheng 7

8 Von Neumann Architecture I/O Devices CPU Memory Connects to: keyboard mouse harddrive printer etc. The Brain, can do: arithmatics logic etc. Contains: program data Put program and data at the same place! 8

9 Memory When you upgrade your laptop s memory, what do you buy? x GB of memory What is an integer? a floating point number? a character? They are just illusions (created by the programming language you use) Memory is just as a bunch of bytes Data structure is just an illusion Why do we need data structures? To organize data stored in memory Make our code easier to maintain, less bugs, etc. Some algorithms run a lot faster if the right data structures are utilized 9

10 Memory Addresses The location of each variable s value in memory is indexed by an address You can talk about the variable named X, or You can alternately talk about the variable that lives at location 1000 int X=102; /* */ 1000 memory address 0x66 content at a memory address 10

11 Memory Addresses The location of each variable s value in memory is indexed by an address You can talk about the variable named X, or You can alternately talk about the variable that lives at location 1000 int X=102; /* */ 1000 memory address 0x66 content at a memory address For int X=102; the above is the wrong picture Need 4 bytes of memory Actually, two choices 11

12 Memory Addresses The location of each variable s value in memory is indexed by an address You can talk about the variable named X, or You can alternately talk about the variable that lives at location 1000 int X=102; /* */ memory address Little-endian 0x66 content at a memory address Ex: Intel 12

13 Memory Addresses The location of each variable s value in memory is indexed by an address You can talk about the variable named X, or You can alternately talk about the variable that lives at location 1000 int X=102; /* */ memory address Big-endian 0x66 content at a memory address Ex: Solaris, PowerPC 13

14 Memory Organization 32-bit address space: Note: if you have a 64-bit machine, things here will be 8 bytes long instead For the rest of the semester, we will assume a 32-bit machine (such as nunki/aludra) Memory Organization code & global/static variables heap 0xffffffff stack Does not have to be all in one large contiguous block Use segments (code segment, data segment, stack segment) Have you heard of segmentation faults? 14

15 Variables Three types of variables Static variable Ex: static int x = 3; Can be inside a function or outside Stack / automatic variable Ex: void foo(int y) int z = y*y; xffffffff Memory Organization code & global/static variables heap stack All local variables live in the stack Heap variable Ex: int *px = (int*)malloc(sizeof(int)); All dynamically allocated variables live in the heap 15

16 Variables and References (Ch 7) Variables Are copied when they are passed into a function Ex: void foo(int y) int z = y*y;... y int main() int x = 102; foo(x); calls foo() main() z x stack 0x28 0x66 0xa4 0x66 x, y, and z all live in the stack x lives in main() s stack frame y and z lives in foo() s stack frame 16

17 Variables and References (Ch 7) References After a reference is created, it cannot be changed Don t have to dereference a reference Why use? Not that useful just being declared in the body of a function As a function parameter, it allows you to modify the original value that was passed in Can use to return multiple values from a function Eliminate the overhead of copying Ex: void foo(int &y) int main() y += 100; int x = 102; foo(x); 17

18 Pointers (Ch 13) Pointers A pointer of any type is a 32-bit number which should be interpreted as an address Pointer variables store a location of something stored elsewhere Rather than refer to a value directly, we can refer to it via its address Why use? Share access to common data (hold onto one copy, everybody points to it) Flexibility (dynamic data structures) Precisely control allocation/deallocation ourselves 18

19 Pointers (Ch 13) static int x = 0x54321; int main() int *p;... 0x20f84 0x05 0x43 0x21 0xffbff74c???? A pointer of any type is a 32-bit number which should be interpreted as an address A pointer of type (X*) with a value of Y means that starting at address Y, interpret it as if there is an object of type X there p contains an address *p means follow the pointer value 19

20 static int x = 5; int main() int *p; p = &x;... Pointers (Ch 13) 0x20f84 0x05 0x43 0x21 0xffbff74c???? A pointer of any type is a 32-bit number which should be interpreted as an address A pointer of type (X*) with a value of Y means that starting at address Y, interpret it as if there is an object of type X there p now contains the address of x 20

21 static int x = 5; int main() int *p; p = &x;... Pointers (Ch 13) 0x20f84 0x05 0x43 0x21 0xffbff74c 0x02 0x0f 0x84 A pointer of any type is a 32-bit number which should be interpreted as an address A pointer of type (X*) with a value of Y means that starting at address Y, interpret it as if there is an object of type X there p now contains the address of x 21

22 static int x = 5; int main() int *p; p = &x;... Pointers (Ch 13) 0x20f84 0x05 0x43 0x21 0xffbff74c A pointer of any type is a 32-bit number which should be interpreted as an address A pointer of type (X*) with a value of Y means that starting at address Y, interpret it as if there is an object of type X there p now contains the address of x usually drawn like a "pointer" starting in p and point to the start of x 22

23 static int x = 5; int main() int *p; p = &x; int y = *p; Pointers (Ch 13) 0x20f84 0x05 0x43 0x21 0xffbff74c 0xffbff750???? A pointer of any type is a 32-bit number which should be interpreted as an address A pointer of type (X*) with a value of Y means that starting at address Y, interpret it as if there is an object of type X there *p means follow the pointer and fetch the content copy that value to y 23

24 static int x = 5; int main() int *p; p = &x; int y = *p; Pointers (Ch 13) 0x20f84 0x05 0x43 0x21 0xffbff74c 0xffbff750 0x05 0x43 0x21 A pointer of any type is a 32-bit number which should be interpreted as an address A pointer of type (X*) with a value of Y means that starting at address Y, interpret it as if there is an object of type X there *p means follow the pointer value and fetch the content copy that value to y 24

25 Pointers Ex: void foo(int *y) (*y) += 100; int main() int x = 102; foo(&x); Pointers (Ch 13) calls foo() main() stack 0xbfffecd0 y 0xbf 0xff 0xbfffedb4 x 0xed 0xb4 0xca 25

26 Pointers Ex: void foo(int *y) (*y) += 100; Pointers (Ch 13) 0x804b008 0xca heap int main() int *px = (int*) malloc(sizeof(int)); if (px!= (int*)0) *px = 102; foo(px); free(px); calls foo() main() stack 0xbfffecd0 y 0x08 0x04 0xb0 0xbfffedb4 px 0x08 0x04 0xb0 0x08 0x08 26

27 Pointers (Ch 13) Pointers Why worry? Must remember to clean up after yourself Usage can be error prone Mistakes don t always show up right away Mistakes can have weird symptoms Memory bugs are hard to understand & fix (even for professionals) 27

28 struct Point char name; int x; int y; ; static Point pt; int main() pt.name = a ; pt.x = 0x12345; pt.y = 0x98765;... All Pointers Are Compatible! 0x20f84 0x20f8c??? 0x01 0x23 0x45 0x09 0x87 0x65 28

29 All Pointers Are Compatible! struct Point char name; int x; int y; ; static Point pt; int main() pt.name = a ; pt.x = 0x12345; pt.y = 0x98765; int *p=(int*)(&pt); cout << hex << "0x" << *p << endl;... 0x x21070??? 0x01 0x23 0x45 0x09 0x87 0x65 0xffbff7bc output: 0x

30 All Pointers Are Compatible! struct Point char name; int x; int y; ; static Point pt; int main() pt.name = a ; pt.x = 0x12345; pt.y = 0x98765; int *p=(int*)(&pt); cout << hex << "0x" << *p << endl; p++; cout << "0x" << setw(8) << setfill( 0 ) << *p << endl;... 0x x21070??? 0x01 0x23 0x45 0x09 0x87 0x65 0xffbff7bc output: 0x

31 All Pointers Are Compatible! struct Point char name; int x; int y; ; static Point pt; int main()... int *p=(int*)(&pt); cout << hex << "0x" << *p << endl; p++; cout << "0x" << setw(8) << setfill( 0 ) << *p << endl; p++; cout << "0x" << setw(8) << setfill( 0 ) << *p << endl; 0x x21070??? 0x01 0x23 0x45 0x09 0x87 0x65 0xffbff7bc output: 0x

32 struct Point char name; int x; int y; ; All Pointers Are Compatible! static int x=0x ; int main() Point *p=(point*)(&x);... 0x20eec 0x67 0x89 0x12 0x34 0xffbff5fc 32

33 struct Point char name; int x; int y; ; All Pointers Are Compatible! static int x=0x ; int main() Point *p=(point*)(&x); cout << (*p).name << endl; 0x20eec 0x67 0x89 0x12 0x34 0xffbff5fc output: g 33

34 Coding Exampls Let s see some code Assigning and passing variables by value Assigning and passing variables by references Assigning and passing pointers Displaying the addresses of variables Debuggers gdb (see quick summary on next slide) ddd (on aludra and nunki) 34

35 The debugger is your friend! Get to know it! compile program with: -g start debugging: gdb hw1 set breakpoint: (gdb) break foo.c:123 run program: (gdb) run clear breakpoint: (gdb) clear stack trace: (gdb) where print field: (gdb) print f.blocktype printf(): (gdb) printf "%02x\n",buf[0] single-step at same level: (gdb) next single-step into a function: (gdb) step print field after every cmd: (gdb) display f.blocktype assignment: (gdb) set f.blocktype=0 continue: (gdb) cont quit: (gdb) quit Notes on gdb 35

36 CS102 Extra Slides Bill Cheng 36

37 variables.cpp /* * 1) Demonstrate static, stack, heap variables. * 2) Declare a static int. * 3) Write a function that returns the square of a number. * 4) In main(), use a stack variable, call square() and print * the number and its square. Call malloc() to create an * integer, call square() and print the number and its square. * 5) Use gdb to look at the addresses. */ 37

38 #include <iostream> using namespace std; static int z=3; int Square(int x) return x*x; variables.cpp int main(int argc, char *argv[]) int x = 17; cout << "Square(" << x << ") = " << Square(x) << endl; int *y = new int(29); cout << "Square(" << *y << ") = " << Square(*y) << endl; delete y; return 0; 38

39 memory.cpp /* * 1) Demonstrate memory management, static, stack, heap * variables. * 2) Define a struct Point with 3 fields: ch, x, y * 3) Declare a static Point. * 4) In main(), declare a Point in the stack. * Assign values to the fields of the stack variable. * Assign values to the fields of the static variable. * Allocate a pointer in the heap. * Assign values to the fields of the dynamic variable. * 5) Use gdb to look at the addresses. */ 39

40 #include <iostream> using namespace std; struct Point char name; int x; int y; ; static Point pt2; memory.cpp int main() Point pt1; pt1.name = 1 ; pt1.x = 123; pt1.y = 456; pt2.name = s ; pt2.x = 0x734; pt2.y = 0x1234; Point *pt3 = (Point*)malloc( sizeof(point)); if (pt3!= (Point*)0) pt3->name = d ; pt3->x = 0x97531; pt3->y = 0x24680; 40

41 values.cpp /* * 1) Demonstrate pass by value semantics. * 2) Write a function that takes in a single integer by value, * prints out its value and address. Keep in mind that "a" * is a COPY of the value that was passed in. * * Don t return a value from this function and see what * happens. * 3) In main(), prints "x" and its address; calls foo(); print * the value returned by foo(); prints "x" and its address * again and see if they have been changed. */ 41

42 #include <iostream> using namespace std; int foo(int a) a += 1; values.cpp cout << a << endl; cout << &a << endl; int main() int x = 5; cout << x << endl; cout << &x << endl; int f = foo(x); cout << "Foo = " << f << endl; cout << x << endl; 42

43 ref.cpp /* * 1) Demonstrate pass by reference semantics. * 2) Write a function that takes in a single integer by * reference, increment "a" by 1 and prints out its value * and address. * * Keep in mind that "a" refers to the same integer as the * caller of foo(). This function returns void. * 3) In main(), prints "x" and its address; calls foo(); * prints "x" again and see if they have been changed. * 4) Add a function to show that we can use pass by reference * to return multiple values from a function. For example, * returns the sum and the average of two integers. * (Is there another way to return multiple values from a * function?) * 5) Show that we can return a reference from a function. * Why is this a bad idea? */ 43

44 #include <iostream> using namespace std; void foo(int& a) a += 1; cout << a << endl; cout << &a << endl; void stats(int a, int b, int &sum, int &avg) sum = a + b; avg = (a + b)/2; int& bar(int a) int c = a + a; return c; ref.cpp int main() int x = 5; cout << x << endl; cout << &x << endl; foo(x); cout << x << endl; int a1 = 123; int a2 = 234; int sum = 0; int avg = 0; stats(a1,a2,sum,avg); int val = 123; int& valref = bar(val); cout << valref << endl; int& xref = x; cout << "xref = " << xref << endl; xref = 22222; cout << x << endl; cout << &x << endl; cout << &xref << endl; 44

45 pointers.cpp /* * 1) Demonstrate pass by pointer semantics. * 2) Write a function that takes in a pointer to an integer, * increment "a" by 1 and prints out its value and address. * Keep in mind that "a" points to the same memory * location as the integer passed by the caller of foo(). * This function returns void. * 3) In main(), prints "x" and its address; calls foo(); * prints "x" again and see if they have been changed. * 4) Shows that, unlike a reference, a single pointer can * be used to point to multiple different values. * 5) Shows that multiple pointers can point to the same value. */ 45

46 #include <iostream> using namespace std; void foo(int* a) (*a) += 1; cout << "a = " << a << endl; pointers.cpp int main() int x = 5; cout << "x = " << x << endl; foo(&x); cout << "x = " << x << endl; x = 5; int* ptr = &x; *ptr = 22222; cout << x << endl; cout << *ptr << endl; cout << &x << endl; cout << ptr << endl; int y = 10; int z = 15; int* newptr = &y; newptr = &z; int w = 22; int* p1 = &w; int* p2 = &w; 46