(New page: Lecture 13 - February 21st - John Ribeiro - Cannot compare two objects directly * Exam 1 on 03/01 in class **Online, open book **File operation, structures, recursion, pointer... **Will...)
 
 
(5 intermediate revisions by 3 users not shown)
Line 1: Line 1:
−
Lecture 13 - February 21st - John Ribeiro
+
[[Category:ECE264]] [[Category:Programming]] [[Category:C]] [[Category:lecture notes]]
  
−
- Cannot compare two objects directly
+
=Lecture 14, [[ECE264]], Spring 2012, Prof. Lu=
 +
----
 +
Lecture 14 - John Ribeiro
  
−
* Exam 1 on 03/01 in class
+
typedef struct
 +
{
 +
  char *name;
 +
  int year;
 +
  int month;
 +
  int date;
 +
} Person;
  
−
**Online, open book
+
Person Person_construct ( char * n , int y, int m, int d )
−
**File operation, structures, recursion, pointer...
+
{
−
**Will receive a zero if a segmentation fault is fount or syntax error
+
  Person p;
 +
  p.name = malloc ( sizeof(char) * ( stnlen(n) + 1 ) );
 +
  strcpy(p.name, n );
 +
  p.year = y;
 +
  p.month = m;
 +
  p.date = d;
 +
  return p;
 +
}
  
−
For Makefile:
+
void Person_destruct ( Person p )
 +
{
 +
  free ( p.name );
 +
}
  
−
GCC = gcc -g -Wall -Wshadow
+
DEEP COPY (AVOID):
−
ipa1: maze.o main.o
+
−
      $(GCC)
+
−
...
+
−
...
+
  
−
test:
+
Person Person_copy ( Person p )
−
    ./ipa1 maze1 > output1
+
{
−
    diff output1 solution1
+
  return Person_constructor(p.name, p.year, p.month, p.date);
−
    ./ipa1 maze2 > output2
+
}
−
    diff output2 solution2
+
  
−
    valgrind --leak-check=yes -v ./ipa1 maze
+
Person Person_assign ( Person p1, Person p2 )
 +
{
 +
  Person_destruct (p1);
 +
  return Person_copy(p2);
 +
}
 +
 
 +
--
 +
 
 +
Person p1 = Person_construct ("alice", 1980, 10, 21);
 +
Person p2 = Person_construct ("genny", 1984, 2, 5 );
 +
Person p3 = Person_copy (p1);
 +
p3 = Person_assign (p3, p2);
  
−
**diff command in Linux will not return anything if no differences are found
+
Person_destruct(p1);
 +
Person_destruct(p2);
 +
Person_destruct(p3);
  
−
-Many problems come from uninitialized variables and pointers. Unpredictable behaviour.
+
Why constructor?
−
-Use invalid values to guarantee programs fail
+
−
-Read your code before testing. Testing won't tell you where the program fails
+
−
-Design your solution on paper before writing code. The sooner you start coding, the later you can finish.
+
  
−
**Read code before testing
+
**A single place where all attributes are assigned
−
 
+
**malloc in constructor
−
  -Make memory allocation and release symmetric
+
   - destructor_copy, assign
−
  -Have only one place to allocate and release memory
+
−
  -Keep functions short
+
−
  -Do not copy and paste code. Use a function instead
+
−
   -Use valgrind, even though program seems to work
+
  
 
typedef struct
 
typedef struct
 
{
 
{
−
   int x;
+
   int year;
−
   int y;
+
   int month;
−
   int z;
+
   int date;
−
} Vector;
+
} DateofBirth;
  
−
void vector_writeb ( char * filename, Vector v )
+
typedef struct
 
{
 
{
−
   fptr = fopen ( filenamme, "wb" );
+
   char *name;
 +
  DateofBirth dob;
 +
} Person;
  
−
  /* "wb" means write binary and "rb" means read binary */
+
* When Person returns, the compiler will copy attribute by attribute
−
}
+
  
−
fwrite (address of object, size, number, file pointer)
+
If P3 = P1; // Shadow copy
  
−
if ( fwrite ( &v, sizeof(Vecotr), 1 , fptr ) != 1 )
+
A shadow copy is when two pointers are assigned the same value in memory i.e the point to the same place
  
−
--NOTE: fwrite returns the number of items it writes
+
int x = 24;
 +
int y = x;
 +
x = 31
 +
y = 31;
  
−
OBJECT W/ POINTERS
+
What is y?
  
−
typedef dstruct
+
Copy on Write - if one pointer changes memory
 +
 
 +
 
 +
/////////////////////////////////////////////
 +
 
 +
LECTURE NOTES_2/23_Kailu Song
 +
 
 +
(WHY CONSTRUCTOR? a single place where all attributes are assigned)
 +
(malloc in constructor = copy+assign+destructor)
 +
 
 +
typed of struct
 
{
 
{
−
   char *name;
+
   char *name;(if structure don't have pointer can write pointer Person P3 = P1; if copy attribute by attribute will get shallow copy)
 
   int year;
 
   int year;
 
   int month;
 
   int month;
−
   int date;
+
   int data;
 
} Person;
 
} Person;
−
 
+
Person Person_construct(char *n, int y, int m, int d)
−
Person Person_constructor ( char * n, int y, int m, int d )
+
 
{
 
{
 
   Person P;
 
   Person P;
−
   p.name = malloc ( sizeof(char) * ( strlen(n) + 1 ) );
+
   P.name = malloc(sizeof(char)*strlen(n)+1);
−
   strcpy ( p.name, n );
+
   (check if P.name is = NULL)
−
   p.year = y;
+
  strepy(P.name,n);
−
 
+
   P.year = y;
−
   return p;
+
  P.month = m;
 +
  P.date = d;
 +
   return P;
 
}
 
}
 +
void Person_destruct(Person P)
 +
{
 +
  free(P.name);
 +
}
 +
Person Person_coty(Person P)
 +
{
 +
  return Person_construct(P.name,P.year,P.month,P.data);  (inside the construct function,there is a malloc, so create another heap memory)
 +
}
 +
Person Person_assign(Person P1, Person P2)
 +
{
 +
  Person_destruct(P1);
 +
  return Person_copy (P2);
 +
}
 +
Person P1 = Person_construct("Amy",1980,10,21);
 +
Person P2 = Person_construct("Jennifer",1981,2,5);
 +
Person P3 = Person_copy(P1);
 +
P3 = Person_assign(P3,P2);(if change this line to P3 = Person_copy(P2),P2 will become leak memory become there are two mallocs)
 +
Person_destruct(P1);
 +
Person_destruct(P2);
 +
Person_destruct(P3);
  
−
MAIN:
+
HINT FOR IPA1-3:
−
 
+
Maze_traverse(Maze xmz, int from, int *forward)
−
Person P = Person_constructor ( "Alice", 1981, 11, 22);
+
−
Person_destruct(P);
+
−
 
+
−
void Person_destruct ( Person p )
+
 
{
 
{
−
   free ( p.name );
+
if (canMove(east))
 +
   {
 +
    forward = 1;
 +
    from = west;
 +
    Maze_traverse(...east);
 +
    book leaping;(dead end)
 +
  }
 +
if (canMove(south))
 +
  {
 +
    forward = 1;
 +
    from = west;
 +
    Maze_traverse(...south);
 +
    book leaping;(dead end)
 +
  }
 +
if (canMove(west))
 +
  {
 +
    forward = 1;
 +
    from = west;
 +
    Maze_traverse(...west);
 +
    book leaping;(dead end)
 +
}
 +
if (canMove(north))
 +
  {
 +
    forward = 1;
 +
    from = west;
 +
    Maze_traverse(...north);
 +
    book leaping;(dead end)
 +
}
 +
canMove
 +
{
 +
CHECK whether it is a brick;
 +
CHECK where you come from;
 +
CHECK whether *forward = 1;
 
}
 
}
 +
----
 +
[[2012_Spring_ECE_264_Lu|Back to ECE264, Spring 2012, Prof. Lu]]

Latest revision as of 04:25, 11 July 2012


Lecture 14, ECE264, Spring 2012, Prof. Lu

Lecture 14 - John Ribeiro

typedef struct { 

 char *name;
 int year;
 int month;
 int date;

} Person;

Person Person_construct ( char * n , int y, int m, int d ) { 

 Person p;
 p.name = malloc ( sizeof(char) * ( stnlen(n) + 1 ) );
 strcpy(p.name, n );
 p.year = y;
 p.month = m;
 p.date = d;
 return p;

}

void Person_destruct ( Person p ) { 

 free ( p.name );

}

DEEP COPY (AVOID):

Person Person_copy ( Person p ) { 

 return Person_constructor(p.name, p.year, p.month, p.date);

}

Person Person_assign ( Person p1, Person p2 ) { 

 Person_destruct (p1);
 return Person_copy(p2);

}

--

Person p1 = Person_construct ("alice", 1980, 10, 21); Person p2 = Person_construct ("genny", 1984, 2, 5 ); Person p3 = Person_copy (p1); p3 = Person_assign (p3, p2);

Person_destruct(p1); Person_destruct(p2); Person_destruct(p3);

Why constructor?

    • A single place where all attributes are assigned
    • malloc in constructor 
 - destructor_copy, assign

typedef struct { 

 int year;
 int month;
 int date;

} DateofBirth;

typedef struct { 

 char *name;
 DateofBirth dob;

} Person;

  • When Person returns, the compiler will copy attribute by attribute

If P3 = P1; // Shadow copy

A shadow copy is when two pointers are assigned the same value in memory i.e the point to the same place

int x = 24; int y = x; x = 31 y = 31;

What is y?

Copy on Write - if one pointer changes memory


/////////////////////////////////////////////

LECTURE NOTES_2/23_Kailu Song

(WHY CONSTRUCTOR? a single place where all attributes are assigned) (malloc in constructor = copy+assign+destructor)

typed of struct { 

 char *name;(if structure don't have pointer can write pointer Person P3 = P1; if copy attribute by attribute will get shallow copy)
 int year;
 int month;
 int data;

} Person; Person Person_construct(char *n, int y, int m, int d) { 

 Person P;
 P.name = malloc(sizeof(char)*strlen(n)+1);
 (check if P.name is = NULL)
 strepy(P.name,n);
 P.year = y;
 P.month = m;
 P.date = d;
 return P;

} void Person_destruct(Person P) { 

 free(P.name);

} Person Person_coty(Person P) { 

 return Person_construct(P.name,P.year,P.month,P.data);  (inside the construct function,there is a malloc, so create another heap memory)

} Person Person_assign(Person P1, Person P2) { 

 Person_destruct(P1);
 return Person_copy (P2);

} Person P1 = Person_construct("Amy",1980,10,21); Person P2 = Person_construct("Jennifer",1981,2,5); Person P3 = Person_copy(P1); P3 = Person_assign(P3,P2);(if change this line to P3 = Person_copy(P2),P2 will become leak memory become there are two mallocs) Person_destruct(P1); Person_destruct(P2); Person_destruct(P3);

HINT FOR IPA1-3: Maze_traverse(Maze xmz, int from, int *forward) { 

if (canMove(east))
 {
   forward = 1;
   from = west;
   Maze_traverse(...east);
   book leaping;(dead end)
 }
if (canMove(south))
 {
   forward = 1;
   from = west;
   Maze_traverse(...south);
   book leaping;(dead end)
 }
if (canMove(west))
 {
   forward = 1;
   from = west;
   Maze_traverse(...west);
   book leaping;(dead end)
}
if (canMove(north))
 {
   forward = 1;
   from = west;
   Maze_traverse(...north);
   book leaping;(dead end)
}

canMove { CHECK whether it is a brick; CHECK where you come from; CHECK whether *forward = 1; }

Back to ECE264, Spring 2012, Prof. Lu

Retrieved from "https://www.projectrhea.org/rhea/index.php?title=Lecture_14_ECE264F12Lu&oldid=51929"
Shortcuts
Help Main Wiki Page Random Page Special Pages Log in
Search

Alumni Liaison

Correspondence Chess Grandmaster and Purdue Alumni

Prof. Dan Fleetwood